lnd.xprv/lncfg/address_test.go

133 lines
3.7 KiB
Go
Raw Normal View History

// +build !rpctest
package lncfg
2018-06-28 01:04:23 +03:00
import (
"net"
"testing"
)
// addressTest defines a test vector for an address that contains the non-
// normalized input and the expected normalized output.
type addressTest struct {
address string
expectedNetwork string
expectedAddress string
isLoopback bool
isUnix bool
}
var (
defaultTestPort = "1234"
addressTestVectors = []addressTest{
{"tcp://127.0.0.1:9735", "tcp", "127.0.0.1:9735", true, false},
{"tcp:127.0.0.1:9735", "tcp", "127.0.0.1:9735", true, false},
{"127.0.0.1:9735", "tcp", "127.0.0.1:9735", true, false},
{":9735", "tcp", ":9735", false, false},
{"", "tcp", ":1234", false, false},
{":", "tcp", ":1234", false, false},
{"tcp4://127.0.0.1:9735", "tcp", "127.0.0.1:9735", true, false},
{"tcp4:127.0.0.1:9735", "tcp", "127.0.0.1:9735", true, false},
{"127.0.0.1", "tcp", "127.0.0.1:1234", true, false},
{"[::1]", "tcp", "[::1]:1234", true, false},
{"::1", "tcp", "[::1]:1234", true, false},
{"tcp6://::1", "tcp", "[::1]:1234", true, false},
{"tcp6:::1", "tcp", "[::1]:1234", true, false},
{"localhost:9735", "tcp", "127.0.0.1:9735", true, false},
{"localhost", "tcp", "127.0.0.1:1234", true, false},
{"unix:///tmp/lnd.sock", "unix", "/tmp/lnd.sock", false, true},
{"unix:/tmp/lnd.sock", "unix", "/tmp/lnd.sock", false, true},
{"123", "tcp", "127.0.0.1:123", true, false},
2018-06-28 01:04:23 +03:00
{
"4acth47i6kxnvkewtm6q7ib2s3ufpo5sqbsnzjpbi7utijcltosqemad.onion",
"tcp",
"4acth47i6kxnvkewtm6q7ib2s3ufpo5sqbsnzjpbi7utijcltosqemad.onion:1234",
false,
false,
},
{
"4acth47i6kxnvkewtm6q7ib2s3ufpo5sqbsnzjpbi7utijcltosqemad.onion:9735",
"tcp",
"4acth47i6kxnvkewtm6q7ib2s3ufpo5sqbsnzjpbi7utijcltosqemad.onion:9735",
false,
false,
},
{
"3g2upl4pq6kufc4m.onion",
"tcp",
"3g2upl4pq6kufc4m.onion:1234",
false,
false,
},
{
"3g2upl4pq6kufc4m.onion:9735",
"tcp",
"3g2upl4pq6kufc4m.onion:9735",
false,
false,
},
}
invalidTestVectors = []string{
"some string",
"://",
"12.12.12.12.12",
}
)
// TestAddresses ensures that all supported address formats can be parsed and
// normalized correctly.
func TestAddresses(t *testing.T) {
// First, test all correct addresses.
2018-06-28 01:04:23 +03:00
for i, testVector := range addressTestVectors {
addr := []string{testVector.address}
2018-06-28 01:04:23 +03:00
normalized, err := NormalizeAddresses(
addr, defaultTestPort, net.ResolveTCPAddr,
)
if err != nil {
2018-06-28 01:04:23 +03:00
t.Fatalf("#%v: unable to normalize address %s: %v",
i, testVector.address, err)
}
netAddr := normalized[0]
if err != nil {
2018-06-28 01:04:23 +03:00
t.Fatalf("#%v: unable to split normalized address: %v", i, err)
}
if netAddr.Network() != testVector.expectedNetwork ||
netAddr.String() != testVector.expectedAddress {
2018-06-28 01:04:23 +03:00
t.Fatalf("#%v: mismatched address: expected %s://%s, "+
"got %s://%s",
i, testVector.expectedNetwork,
testVector.expectedAddress,
netAddr.Network(), netAddr.String(),
)
}
isAddrLoopback := IsLoopback(normalized[0])
if testVector.isLoopback != isAddrLoopback {
2018-06-28 01:04:23 +03:00
t.Fatalf("#%v: mismatched loopback detection: expected "+
"%v, got %v for addr %s",
i, testVector.isLoopback, isAddrLoopback,
testVector.address,
)
}
isAddrUnix := IsUnix(normalized[0])
if testVector.isUnix != isAddrUnix {
2018-06-28 01:04:23 +03:00
t.Fatalf("#%v: mismatched unix detection: expected "+
"%v, got %v for addr %s",
i, testVector.isUnix, isAddrUnix,
testVector.address,
)
}
}
// Finally, test invalid inputs to see if they are handled correctly.
for _, testVector := range invalidTestVectors {
addr := []string{testVector}
2018-06-28 01:04:23 +03:00
_, err := NormalizeAddresses(
addr, defaultTestPort, net.ResolveTCPAddr,
)
if err == nil {
2018-06-28 01:04:23 +03:00
t.Fatalf("expected error when parsing %v", testVector)
}
}
}