mirror of
https://github.com/fluencelabs/tendermint
synced 2025-05-21 02:31:19 +00:00
ca00cd6a78
This cuts out two tests by constructing test cases and iterating through them, rather than having separate sets of tests for TCP and Unix listeners. This is as per the feedback from #3121.
134 lines
3.2 KiB
Go
134 lines
3.2 KiB
Go
package privval
|
|
|
|
import (
|
|
"io/ioutil"
|
|
"net"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
)
|
|
|
|
//-------------------------------------------
|
|
// helper funcs
|
|
|
|
func newPrivKey() ed25519.PrivKeyEd25519 {
|
|
return ed25519.GenPrivKey()
|
|
}
|
|
|
|
//-------------------------------------------
|
|
// tests
|
|
|
|
type listenerTestCase struct {
|
|
description string // For test reporting purposes.
|
|
listener net.Listener
|
|
dialer Dialer
|
|
}
|
|
|
|
// getTestUnixAddr will attempt to obtain a platform-independent temporary file
|
|
// name for a Unix socket
|
|
func getTestUnixAddr() (string, error) {
|
|
f, err := ioutil.TempFile("", "tendermint-privval-test")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
addr := f.Name()
|
|
f.Close()
|
|
os.Remove(addr)
|
|
return addr, nil
|
|
}
|
|
|
|
func constructTCPListenerTestCase(t *testing.T, acceptDeadline, connectDeadline time.Duration) listenerTestCase {
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tcpLn := NewTCPListener(ln, newPrivKey())
|
|
TCPListenerAcceptDeadline(acceptDeadline)(tcpLn)
|
|
TCPListenerConnDeadline(connectDeadline)(tcpLn)
|
|
return listenerTestCase{
|
|
description: "TCP",
|
|
listener: tcpLn,
|
|
dialer: DialTCPFn(ln.Addr().String(), testConnDeadline, newPrivKey()),
|
|
}
|
|
}
|
|
|
|
func constructUnixListenerTestCase(t *testing.T, acceptDeadline, connectDeadline time.Duration) listenerTestCase {
|
|
addr, err := getTestUnixAddr()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ln, err := net.Listen("unix", addr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
unixLn := NewUnixListener(ln)
|
|
UnixListenerAcceptDeadline(acceptDeadline)(unixLn)
|
|
UnixListenerConnDeadline(connectDeadline)(unixLn)
|
|
return listenerTestCase{
|
|
description: "Unix",
|
|
listener: unixLn,
|
|
dialer: DialUnixFn(addr),
|
|
}
|
|
}
|
|
|
|
func constructListenerTestCases(t *testing.T, acceptDeadline, connectDeadline time.Duration) []listenerTestCase {
|
|
return []listenerTestCase{
|
|
constructTCPListenerTestCase(t, acceptDeadline, connectDeadline),
|
|
constructUnixListenerTestCase(t, acceptDeadline, connectDeadline),
|
|
}
|
|
}
|
|
|
|
func TestListenerAcceptDeadlines(t *testing.T) {
|
|
for _, tc := range constructListenerTestCases(t, time.Millisecond, time.Second) {
|
|
_, err := tc.listener.Accept()
|
|
opErr, ok := err.(*net.OpError)
|
|
if !ok {
|
|
t.Fatalf("for %s listener, have %v, want *net.OpError", tc.description, err)
|
|
}
|
|
|
|
if have, want := opErr.Op, "accept"; have != want {
|
|
t.Errorf("for %s listener, have %v, want %v", tc.description, have, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListenerConnectDeadlines(t *testing.T) {
|
|
for _, tc := range constructListenerTestCases(t, time.Second, time.Millisecond) {
|
|
readyc := make(chan struct{})
|
|
donec := make(chan struct{})
|
|
go func(ln net.Listener) {
|
|
defer close(donec)
|
|
|
|
c, err := ln.Accept()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
<-readyc
|
|
|
|
time.Sleep(2 * time.Millisecond)
|
|
|
|
msg := make([]byte, 200)
|
|
_, err = c.Read(msg)
|
|
opErr, ok := err.(*net.OpError)
|
|
if !ok {
|
|
t.Fatalf("for %s listener, have %v, want *net.OpError", tc.description, err)
|
|
}
|
|
|
|
if have, want := opErr.Op, "read"; have != want {
|
|
t.Errorf("for %s listener, have %v, want %v", tc.description, have, want)
|
|
}
|
|
}(tc.listener)
|
|
|
|
_, err := tc.dialer()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
close(readyc)
|
|
<-donec
|
|
}
|
|
}
|