netbird/ice
0
0
Fork 0
mirror of https://github.com/netbirdio/ice.git synced 2026-05-22 17:10:58 -07:00
Code Issues Packages Projects Releases Wiki Activity

Use testify/require instead of testify/assert

Browse Source 
Don't continue to run a test if it has already failed
This commit is contained in:
Steffen Vogel
2024-03-23 07:42:06 -04:00
committed by Sean DuBois
parent fdca6c47c0
commit 05ab684741
19 changed files with 533 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files
active_tcp_test.go
+4 -5
View File
@@ -14,7 +14,6 @@ import (
"github.com/pion/logging"
"github.com/pion/transport/v3/stdnet"
"github.com/pion/transport/v3/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -199,12 +198,12 @@ func TestActiveTCP_NonBlocking(t *testing.T) {
if err != nil {
t.Fatal(err)
}
assert.NoError(t, aAgent.AddRemoteCandidate(invalidCandidate))
assert.NoError(t, bAgent.AddRemoteCandidate(invalidCandidate))
require.NoError(t, aAgent.AddRemoteCandidate(invalidCandidate))
require.NoError(t, bAgent.AddRemoteCandidate(invalidCandidate))
connect(aAgent, bAgent)
<-isConnected
assert.NoError(t, aAgent.Close())
assert.NoError(t, bAgent.Close())
require.NoError(t, aAgent.Close())
require.NoError(t, bAgent.Close())
}
agent_get_best_valid_candidate_pair_test.go
+1 -2
View File
@@ -9,7 +9,6 @@ package ice
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -28,7 +27,7 @@ func TestAgentGetBestValidCandidatePair(t *testing.T) {
require.Equal(t, actualBestPair.String(), expectedBestPair.String())
}
assert.NoError(t, f.sut.Close())
require.NoError(t, f.sut.Close())
}
func setupTestAgentGetBestValidCandidatePair(t *testing.T) *TestAgentGetBestValidCandidatePairFixture {
agent_test.go
+146 -153
View File
File diff suppressed because it is too large Load Diff
candidate_relay_test.go
+6 -6
View File
@@ -15,7 +15,7 @@ import (
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/pion/turn/v3"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func optimisticAuthHandler(string, string, net.Addr) (key []byte, ok bool) {
@@ -32,7 +32,7 @@ func TestRelayOnlyConnection(t *testing.T) {
serverPort := randomPort(t)
serverListener, err := net.ListenPacket("udp", localhostIPStr+":"+strconv.Itoa(serverPort))
assert.NoError(t, err)
require.NoError(t, err)
server, err := turn.NewServer(turn.ServerConfig{
Realm: "pion.ly",
@@ -44,7 +44,7 @@ func TestRelayOnlyConnection(t *testing.T) {
},
},
})
assert.NoError(t, err)
require.NoError(t, err)
cfg := &AgentConfig{
NetworkTypes: supportedNetworkTypes(),
@@ -85,7 +85,7 @@ func TestRelayOnlyConnection(t *testing.T) {
<-aConnected
<-bConnected
assert.NoError(t, aAgent.Close())
assert.NoError(t, bAgent.Close())
assert.NoError(t, server.Close())
require.NoError(t, aAgent.Close())
require.NoError(t, bAgent.Close())
require.NoError(t, server.Close())
}
candidate_server_reflexive_test.go
+6 -6
View File
@@ -15,7 +15,7 @@ import (
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/pion/turn/v3"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestServerReflexiveOnlyConnection(t *testing.T) {
@@ -28,7 +28,7 @@ func TestServerReflexiveOnlyConnection(t *testing.T) {
serverPort := randomPort(t)
serverListener, err := net.ListenPacket("udp4", "127.0.0.1:"+strconv.Itoa(serverPort))
assert.NoError(t, err)
require.NoError(t, err)
server, err := turn.NewServer(turn.ServerConfig{
Realm: "pion.ly",
@@ -40,7 +40,7 @@ func TestServerReflexiveOnlyConnection(t *testing.T) {
},
},
})
assert.NoError(t, err)
require.NoError(t, err)
cfg := &AgentConfig{
NetworkTypes: []NetworkType{NetworkTypeUDP4},
@@ -78,7 +78,7 @@ func TestServerReflexiveOnlyConnection(t *testing.T) {
<-aConnected
<-bConnected
assert.NoError(t, aAgent.Close())
assert.NoError(t, bAgent.Close())
assert.NoError(t, server.Close())
require.NoError(t, aAgent.Close())
require.NoError(t, bAgent.Close())
require.NoError(t, server.Close())
}
candidate_test.go
+15 -16
View File
@@ -9,7 +9,6 @@ import (
"time"
"github.com/pion/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -183,23 +182,23 @@ func TestCandidatePriority(t *testing.T) {
func TestCandidateLastSent(t *testing.T) {
candidate := candidateBase{}
assert.Equal(t, candidate.LastSent(), time.Time{})
require.Equal(t, candidate.LastSent(), time.Time{})
now := time.Now()
candidate.setLastSent(now)
assert.Equal(t, candidate.LastSent(), now)
require.Equal(t, candidate.LastSent(), now)
}
func TestCandidateLastReceived(t *testing.T) {
candidate := candidateBase{}
assert.Equal(t, candidate.LastReceived(), time.Time{})
require.Equal(t, candidate.LastReceived(), time.Time{})
now := time.Now()
candidate.setLastReceived(now)
assert.Equal(t, candidate.LastReceived(), now)
require.Equal(t, candidate.LastReceived(), now)
}
func TestCandidateFoundation(t *testing.T) {
// All fields are the same
assert.Equal(t,
require.Equal(t,
(&candidateBase{
candidateType: CandidateTypeHost,
networkType: NetworkTypeUDP4,
@@ -212,7 +211,7 @@ func TestCandidateFoundation(t *testing.T) {
}).Foundation())
// Different Address
assert.NotEqual(t,
require.NotEqual(t,
(&candidateBase{
candidateType: CandidateTypeHost,
networkType: NetworkTypeUDP4,
@@ -225,7 +224,7 @@ func TestCandidateFoundation(t *testing.T) {
}).Foundation())
// Different networkType
assert.NotEqual(t,
require.NotEqual(t,
(&candidateBase{
candidateType: CandidateTypeHost,
networkType: NetworkTypeUDP4,
@@ -238,7 +237,7 @@ func TestCandidateFoundation(t *testing.T) {
}).Foundation())
// Different candidateType
assert.NotEqual(t,
require.NotEqual(t,
(&candidateBase{
candidateType: CandidateTypeHost,
networkType: NetworkTypeUDP4,
@@ -251,7 +250,7 @@ func TestCandidateFoundation(t *testing.T) {
}).Foundation())
// Port has no effect
assert.Equal(t,
require.Equal(t,
(&candidateBase{
candidateType: CandidateTypeHost,
networkType: NetworkTypeUDP4,
@@ -387,14 +386,14 @@ func TestCandidateMarshal(t *testing.T) {
} {
actualCandidate, err := UnmarshalCandidate(test.marshaled)
if test.expectError {
assert.Error(t, err)
require.Error(t, err)
continue
}
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, test.candidate.Equal(actualCandidate))
assert.Equal(t, test.marshaled, actualCandidate.Marshal())
require.True(t, test.candidate.Equal(actualCandidate))
require.Equal(t, test.marshaled, actualCandidate.Marshal())
}
}
@@ -429,11 +428,11 @@ func TestCandidateWriteTo(t *testing.T) {
}
_, err = c1.writeTo([]byte("test"), c2)
assert.NoError(t, err, "writing to open conn")
require.NoError(t, err, "writing to open conn")
err = packetConn.Close()
require.NoError(t, err, "error closing test TCP connection")
_, err = c1.writeTo([]byte("test"), c2)
assert.Error(t, err, "writing to closed conn")
require.Error(t, err, "writing to closed conn")
}
candidatepair_test.go
+2 -2
View File
@@ -6,7 +6,7 @@ package ice
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func hostCandidate() *CandidateHost {
@@ -132,5 +132,5 @@ func TestCandidatePairEquality(t *testing.T) {
func TestNilCandidatePairString(t *testing.T) {
var nilCandidatePair *CandidatePair
assert.Equal(t, nilCandidatePair.String(), "")
require.Equal(t, nilCandidatePair.String(), "")
}
connectivity_vnet_test.go
+43 -63
View File
@@ -19,7 +19,7 @@ import (
"github.com/pion/transport/v3/test"
"github.com/pion/transport/v3/vnet"
"github.com/pion/turn/v3"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
const (
@@ -292,13 +292,9 @@ func pipeWithVNet(v *virtualNet, a0TestConfig, a1TestConfig *agentTestConfig) (*
return aConn, bConn
}
func closePipe(t *testing.T, ca *Conn, cb *Conn) bool {
err := ca.Close()
if !assert.NoError(t, err, "should succeed") {
return false
}
err = cb.Close()
return assert.NoError(t, err, "should succeed")
func closePipe(t *testing.T, ca *Conn, cb *Conn) {
require.NoError(t, ca.Close())
require.NoError(t, cb.Close())
}
func TestConnectivityVNet(t *testing.T) {
@@ -332,9 +328,7 @@ func TestConnectivityVNet(t *testing.T) {
}
v, err := buildVNet(natType, natType)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
defer v.close()
log.Debug("Connecting...")
@@ -353,9 +347,7 @@ func TestConnectivityVNet(t *testing.T) {
time.Sleep(1 * time.Second)
log.Debug("Closing...")
if !closePipe(t, ca, cb) {
return
}
closePipe(t, ca, cb)
})
t.Run("Symmetric NATs on both ends", func(t *testing.T) {
@@ -369,9 +361,7 @@ func TestConnectivityVNet(t *testing.T) {
}
v, err := buildVNet(natType, natType)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
defer v.close()
log.Debug("Connecting...")
@@ -389,9 +379,7 @@ func TestConnectivityVNet(t *testing.T) {
ca, cb := pipeWithVNet(v, a0TestConfig, a1TestConfig)
log.Debug("Closing...")
if !closePipe(t, ca, cb) {
return
}
closePipe(t, ca, cb)
})
t.Run("1:1 NAT with host candidate vs Symmetric NATs", func(t *testing.T) {
@@ -409,9 +397,7 @@ func TestConnectivityVNet(t *testing.T) {
}
v, err := buildVNet(natType0, natType1)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
defer v.close()
log.Debug("Connecting...")
@@ -425,9 +411,7 @@ func TestConnectivityVNet(t *testing.T) {
ca, cb := pipeWithVNet(v, a0TestConfig, a1TestConfig)
log.Debug("Closing...")
if !closePipe(t, ca, cb) {
return
}
closePipe(t, ca, cb)
})
t.Run("1:1 NAT with srflx candidate vs Symmetric NATs", func(t *testing.T) {
@@ -445,9 +429,7 @@ func TestConnectivityVNet(t *testing.T) {
}
v, err := buildVNet(natType0, natType1)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
defer v.close()
log.Debug("Connecting...")
@@ -461,13 +443,11 @@ func TestConnectivityVNet(t *testing.T) {
ca, cb := pipeWithVNet(v, a0TestConfig, a1TestConfig)
log.Debug("Closing...")
if !closePipe(t, ca, cb) {
return
}
closePipe(t, ca, cb)
})
}
// TestDisconnectedToConnected asserts that an agent can go to disconnected, and then return to connected successfully
// TestDisconnectedToConnected requires that an agent can go to disconnected, and then return to connected successfully
func TestDisconnectedToConnected(t *testing.T) {
report := test.CheckRoutines(t)
defer report()
@@ -482,7 +462,7 @@ func TestDisconnectedToConnected(t *testing.T) {
CIDR: "0.0.0.0/0",
LoggerFactory: loggerFactory,
})
assert.NoError(t, err)
require.NoError(t, err)
var dropAllData uint64
wan.AddChunkFilter(func(vnet.Chunk) bool {
@@ -492,16 +472,16 @@ func TestDisconnectedToConnected(t *testing.T) {
net0, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{"192.168.0.1"},
})
assert.NoError(t, err)
assert.NoError(t, wan.AddNet(net0))
require.NoError(t, err)
require.NoError(t, wan.AddNet(net0))
net1, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{"192.168.0.2"},
})
assert.NoError(t, err)
assert.NoError(t, wan.AddNet(net1))
require.NoError(t, err)
require.NoError(t, wan.AddNet(net1))
assert.NoError(t, wan.Start())
require.NoError(t, wan.Start())
disconnectTimeout := time.Second
keepaliveInterval := time.Millisecond * 20
@@ -515,7 +495,7 @@ func TestDisconnectedToConnected(t *testing.T) {
KeepaliveInterval: &keepaliveInterval,
CheckInterval: &keepaliveInterval,
})
assert.NoError(t, err)
require.NoError(t, err)
controlledAgent, err := NewAgent(&AgentConfig{
NetworkTypes: supportedNetworkTypes(),
@@ -525,15 +505,15 @@ func TestDisconnectedToConnected(t *testing.T) {
KeepaliveInterval: &keepaliveInterval,
CheckInterval: &keepaliveInterval,
})
assert.NoError(t, err)
require.NoError(t, err)
controllingStateChanges := make(chan ConnectionState, 100)
assert.NoError(t, controllingAgent.OnConnectionStateChange(func(c ConnectionState) {
require.NoError(t, controllingAgent.OnConnectionStateChange(func(c ConnectionState) {
controllingStateChanges <- c
}))
controlledStateChanges := make(chan ConnectionState, 100)
assert.NoError(t, controlledAgent.OnConnectionStateChange(func(c ConnectionState) {
require.NoError(t, controlledAgent.OnConnectionStateChange(func(c ConnectionState) {
controlledStateChanges <- c
}))
@@ -560,9 +540,9 @@ func TestDisconnectedToConnected(t *testing.T) {
blockUntilStateSeen(ConnectionStateConnected, controllingStateChanges)
blockUntilStateSeen(ConnectionStateConnected, controlledStateChanges)
assert.NoError(t, wan.Stop())
assert.NoError(t, controllingAgent.Close())
assert.NoError(t, controlledAgent.Close())
require.NoError(t, wan.Stop())
require.NoError(t, controllingAgent.Close())
require.NoError(t, controlledAgent.Close())
}
// Agent.Write should use the best valid pair if a selected pair is not yet available
@@ -580,7 +560,7 @@ func TestWriteUseValidPair(t *testing.T) {
CIDR: "0.0.0.0/0",
LoggerFactory: loggerFactory,
})
assert.NoError(t, err)
require.NoError(t, err)
wan.AddChunkFilter(func(c vnet.Chunk) bool {
if stun.IsMessage(c.UserData()) {
@@ -600,16 +580,16 @@ func TestWriteUseValidPair(t *testing.T) {
net0, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{"192.168.0.1"},
})
assert.NoError(t, err)
assert.NoError(t, wan.AddNet(net0))
require.NoError(t, err)
require.NoError(t, wan.AddNet(net0))
net1, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{"192.168.0.2"},
})
assert.NoError(t, err)
assert.NoError(t, wan.AddNet(net1))
require.NoError(t, err)
require.NoError(t, wan.AddNet(net1))
assert.NoError(t, wan.Start())
require.NoError(t, wan.Start())
// Create two agents and connect them
controllingAgent, err := NewAgent(&AgentConfig{
@@ -617,25 +597,25 @@ func TestWriteUseValidPair(t *testing.T) {
MulticastDNSMode: MulticastDNSModeDisabled,
Net: net0,
})
assert.NoError(t, err)
require.NoError(t, err)
controlledAgent, err := NewAgent(&AgentConfig{
NetworkTypes: supportedNetworkTypes(),
MulticastDNSMode: MulticastDNSModeDisabled,
Net: net1,
})
assert.NoError(t, err)
require.NoError(t, err)
gatherAndExchangeCandidates(controllingAgent, controlledAgent)
controllingUfrag, controllingPwd, err := controllingAgent.GetLocalUserCredentials()
assert.NoError(t, err)
require.NoError(t, err)
controlledUfrag, controlledPwd, err := controlledAgent.GetLocalUserCredentials()
assert.NoError(t, err)
require.NoError(t, err)
assert.NoError(t, controllingAgent.startConnectivityChecks(true, controlledUfrag, controlledPwd))
assert.NoError(t, controlledAgent.startConnectivityChecks(false, controllingUfrag, controllingPwd))
require.NoError(t, controllingAgent.startConnectivityChecks(true, controlledUfrag, controlledPwd))
require.NoError(t, controlledAgent.startConnectivityChecks(false, controllingUfrag, controllingPwd))
testMessage := []byte("Test Message")
go func() {
@@ -650,11 +630,11 @@ func TestWriteUseValidPair(t *testing.T) {
readBuf := make([]byte, len(testMessage))
_, err = (&Conn{agent: controlledAgent}).Read(readBuf)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, readBuf, testMessage)
require.Equal(t, readBuf, testMessage)
assert.NoError(t, wan.Stop())
assert.NoError(t, controllingAgent.Close())
assert.NoError(t, controlledAgent.Close())
require.NoError(t, wan.Stop())
require.NoError(t, controllingAgent.Close())
require.NoError(t, controlledAgent.Close())
}
external_ip_mapper_test.go
+99 -99
View File
@@ -7,7 +7,7 @@ import (
"net"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestExternalIPMapper(t *testing.T) {
@@ -17,17 +17,17 @@ func TestExternalIPMapper(t *testing.T) {
var err error
ip, isIPv4, err = validateIPString("1.2.3.4")
assert.NoError(t, err, "should succeed")
assert.True(t, isIPv4, "should be true")
assert.Equal(t, "1.2.3.4", ip.String(), "should be true")
require.NoError(t, err, "should succeed")
require.True(t, isIPv4, "should be true")
require.Equal(t, "1.2.3.4", ip.String(), "should be true")
ip, isIPv4, err = validateIPString("2601:4567::5678")
assert.NoError(t, err, "should succeed")
assert.False(t, isIPv4, "should be false")
assert.Equal(t, "2601:4567::5678", ip.String(), "should be true")
require.NoError(t, err, "should succeed")
require.False(t, isIPv4, "should be false")
require.Equal(t, "2601:4567::5678", ip.String(), "should be true")
_, _, err = validateIPString("bad.6.6.6")
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
})
t.Run("newExternalIPMapper", func(t *testing.T) {
@@ -36,106 +36,106 @@ func TestExternalIPMapper(t *testing.T) {
// ips being nil should succeed but mapper will be nil also
m, err = newExternalIPMapper(CandidateTypeUnspecified, nil)
assert.NoError(t, err, "should succeed")
assert.Nil(t, m, "should be nil")
require.NoError(t, err, "should succeed")
require.Nil(t, m, "should be nil")
// ips being empty should succeed but mapper will still be nil
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{})
assert.NoError(t, err, "should succeed")
assert.Nil(t, m, "should be nil")
require.NoError(t, err, "should succeed")
require.Nil(t, m, "should be nil")
// IPv4 with no explicit local IP, defaults to CandidateTypeHost
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.Equal(t, CandidateTypeHost, m.candidateType, "should match")
assert.NotNil(t, m.ipv4Mapping.ipSole)
assert.Nil(t, m.ipv6Mapping.ipSole)
assert.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
assert.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.Equal(t, CandidateTypeHost, m.candidateType, "should match")
require.NotNil(t, m.ipv4Mapping.ipSole)
require.Nil(t, m.ipv6Mapping.ipSole)
require.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
require.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
// IPv4 with no explicit local IP, using CandidateTypeServerReflexive
m, err = newExternalIPMapper(CandidateTypeServerReflexive, []string{
"1.2.3.4",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.Equal(t, CandidateTypeServerReflexive, m.candidateType, "should match")
assert.NotNil(t, m.ipv4Mapping.ipSole)
assert.Nil(t, m.ipv6Mapping.ipSole)
assert.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
assert.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.Equal(t, CandidateTypeServerReflexive, m.candidateType, "should match")
require.NotNil(t, m.ipv4Mapping.ipSole)
require.Nil(t, m.ipv6Mapping.ipSole)
require.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
require.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
// IPv4 with no explicit local IP, defaults to CandidateTypeHost
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"2601:4567::5678",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.Equal(t, CandidateTypeHost, m.candidateType, "should match")
assert.Nil(t, m.ipv4Mapping.ipSole)
assert.NotNil(t, m.ipv6Mapping.ipSole)
assert.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
assert.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.Equal(t, CandidateTypeHost, m.candidateType, "should match")
require.Nil(t, m.ipv4Mapping.ipSole)
require.NotNil(t, m.ipv6Mapping.ipSole)
require.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
require.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
// IPv4 and IPv6 in the mix
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4",
"2601:4567::5678",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.Equal(t, CandidateTypeHost, m.candidateType, "should match")
assert.NotNil(t, m.ipv4Mapping.ipSole)
assert.NotNil(t, m.ipv6Mapping.ipSole)
assert.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
assert.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.Equal(t, CandidateTypeHost, m.candidateType, "should match")
require.NotNil(t, m.ipv4Mapping.ipSole)
require.NotNil(t, m.ipv6Mapping.ipSole)
require.Equal(t, 0, len(m.ipv4Mapping.ipMap), "should match")
require.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
// Unsupported candidate type - CandidateTypePeerReflexive
m, err = newExternalIPMapper(CandidateTypePeerReflexive, []string{
"1.2.3.4",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Unsupported candidate type - CandidateTypeRelay
m, err = newExternalIPMapper(CandidateTypePeerReflexive, []string{
"1.2.3.4",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Cannot duplicate mapping IPv4 family
m, err = newExternalIPMapper(CandidateTypeServerReflexive, []string{
"1.2.3.4",
"5.6.7.8",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Cannot duplicate mapping IPv6 family
m, err = newExternalIPMapper(CandidateTypeServerReflexive, []string{
"2201::1",
"2201::0002",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Invalide external IP string
m, err = newExternalIPMapper(CandidateTypeServerReflexive, []string{
"bad.2.3.4",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Invalide local IP string
m, err = newExternalIPMapper(CandidateTypeServerReflexive, []string{
"1.2.3.4/10.0.0.bad",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
})
t.Run("newExternalIPMapper with explicit local IP", func(t *testing.T) {
@@ -146,50 +146,50 @@ func TestExternalIPMapper(t *testing.T) {
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4/10.0.0.1",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.Equal(t, CandidateTypeHost, m.candidateType, "should match")
assert.Nil(t, m.ipv4Mapping.ipSole)
assert.Nil(t, m.ipv6Mapping.ipSole)
assert.Equal(t, 1, len(m.ipv4Mapping.ipMap), "should match")
assert.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.Equal(t, CandidateTypeHost, m.candidateType, "should match")
require.Nil(t, m.ipv4Mapping.ipSole)
require.Nil(t, m.ipv6Mapping.ipSole)
require.Equal(t, 1, len(m.ipv4Mapping.ipMap), "should match")
require.Equal(t, 0, len(m.ipv6Mapping.ipMap), "should match")
// Cannot assign two ext IPs for one local IPv4
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4/10.0.0.1",
"1.2.3.5/10.0.0.1",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Cannot assign two ext IPs for one local IPv6
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"2200::1/fe80::1",
"2200::0002/fe80::1",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Cannot mix different IP family in a pair (1)
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"2200::1/10.0.0.1",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Cannot mix different IP family in a pair (2)
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4/fe80::1",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
// Invalid pair
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4/192.168.0.2/10.0.0.1",
})
assert.Error(t, err, "should fail")
assert.Nil(t, m, "should be nil")
require.Error(t, err, "should fail")
require.Nil(t, m, "should be nil")
})
t.Run("newExternalIPMapper with implicit and explicit local IP", func(t *testing.T) {
@@ -198,14 +198,14 @@ func TestExternalIPMapper(t *testing.T) {
"1.2.3.4",
"1.2.3.5/10.0.0.1",
})
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
// Mixing implicit and explicit local IPs not allowed
_, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.5/10.0.0.1",
"1.2.3.4",
})
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
})
t.Run("findExternalIP without explicit local IP", func(t *testing.T) {
@@ -218,24 +218,24 @@ func TestExternalIPMapper(t *testing.T) {
"1.2.3.4",
"2200::1",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
assert.NotNil(t, m.ipv4Mapping.ipSole)
assert.NotNil(t, m.ipv6Mapping.ipSole)
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
require.NotNil(t, m.ipv4Mapping.ipSole)
require.NotNil(t, m.ipv6Mapping.ipSole)
// Find external IPv4
extIP, err = m.findExternalIP("10.0.0.1")
assert.NoError(t, err, "should succeed")
assert.Equal(t, "1.2.3.4", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "1.2.3.4", extIP.String(), "should match")
// Find external IPv6
extIP, err = m.findExternalIP("fe80::0001") // Use '0001' instead of '1' on purpose
assert.NoError(t, err, "should succeed")
assert.Equal(t, "2200::1", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "2200::1", extIP.String(), "should match")
// Bad local IP string
_, err = m.findExternalIP("really.bad")
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
})
t.Run("findExternalIP with explicit local IP", func(t *testing.T) {
@@ -250,36 +250,36 @@ func TestExternalIPMapper(t *testing.T) {
"2200::1/fe80::1",
"2200::2/fe80::2",
})
assert.NoError(t, err, "should succeed")
assert.NotNil(t, m, "should not be nil")
require.NoError(t, err, "should succeed")
require.NotNil(t, m, "should not be nil")
// Find external IPv4
extIP, err = m.findExternalIP("10.0.0.1")
assert.NoError(t, err, "should succeed")
assert.Equal(t, "1.2.3.4", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "1.2.3.4", extIP.String(), "should match")
extIP, err = m.findExternalIP("10.0.0.2")
assert.NoError(t, err, "should succeed")
assert.Equal(t, "1.2.3.5", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "1.2.3.5", extIP.String(), "should match")
_, err = m.findExternalIP("10.0.0.3")
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
// Find external IPv6
extIP, err = m.findExternalIP("fe80::0001") // Use '0001' instead of '1' on purpose
assert.NoError(t, err, "should succeed")
assert.Equal(t, "2200::1", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "2200::1", extIP.String(), "should match")
extIP, err = m.findExternalIP("fe80::0002") // Use '0002' instead of '2' on purpose
assert.NoError(t, err, "should succeed")
assert.Equal(t, "2200::2", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "2200::2", extIP.String(), "should match")
_, err = m.findExternalIP("fe80::3")
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
// Bad local IP string
_, err = m.findExternalIP("really.bad")
assert.Error(t, err, "should fail")
require.Error(t, err, "should fail")
})
t.Run("findExternalIP with empty map", func(t *testing.T) {
@@ -289,21 +289,21 @@ func TestExternalIPMapper(t *testing.T) {
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"1.2.3.4",
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
// Attempt to find IPv6 that does not exist in the map
extIP, err := m.findExternalIP("fe80::1")
assert.NoError(t, err, "should succeed")
assert.Equal(t, "fe80::1", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "fe80::1", extIP.String(), "should match")
m, err = newExternalIPMapper(CandidateTypeUnspecified, []string{
"2200::1",
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
// Attempt to find IPv4 that does not exist in the map
extIP, err = m.findExternalIP("10.0.0.1")
assert.NoError(t, err, "should succeed")
assert.Equal(t, "10.0.0.1", extIP.String(), "should match")
require.NoError(t, err, "should succeed")
require.Equal(t, "10.0.0.1", extIP.String(), "should match")
})
}
gather_test.go
+100 -101
View File
File diff suppressed because it is too large Load Diff
gather_vnet_test.go
+40 -44
View File
@@ -17,7 +17,7 @@ import (
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/pion/transport/v3/vnet"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestVNetGather(t *testing.T) {
@@ -28,12 +28,12 @@ func TestVNetGather(t *testing.T) {
t.Run("No local IP address", func(t *testing.T) {
n, err := vnet.NewNet(&vnet.NetConfig{})
assert.NoError(t, err)
require.NoError(t, err)
a, err := NewAgent(&AgentConfig{
Net: n,
})
assert.NoError(t, err)
require.NoError(t, err)
localIPs, err := localInterfaces(a.net, a.interfaceFilter, a.ipFilter, []NetworkType{NetworkTypeUDP4}, false)
if len(localIPs) > 0 {
@@ -42,7 +42,7 @@ func TestVNetGather(t *testing.T) {
t.Fatal(err)
}
assert.NoError(t, a.Close())
require.NoError(t, a.Close())
})
t.Run("Gather a dynamic IP address", func(t *testing.T) {
@@ -73,7 +73,7 @@ func TestVNetGather(t *testing.T) {
a, err := NewAgent(&AgentConfig{
Net: nw,
})
assert.NoError(t, err)
require.NoError(t, err)
localIPs, err := localInterfaces(a.net, a.interfaceFilter, a.ipFilter, []NetworkType{NetworkTypeUDP4}, false)
if len(localIPs) == 0 {
@@ -91,7 +91,7 @@ func TestVNetGather(t *testing.T) {
}
}
assert.NoError(t, a.Close())
require.NoError(t, a.Close())
})
t.Run("listenUDP", func(t *testing.T) {
@@ -157,8 +157,8 @@ func TestVNetGather(t *testing.T) {
t.Fatalf("listenUDP with port restriction of 5000 listened on incorrect port (%s)", port)
}
assert.NoError(t, conn.Close())
assert.NoError(t, a.Close())
require.NoError(t, conn.Close())
require.NoError(t, a.Close())
})
}
@@ -181,7 +181,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
CIDR: "1.2.3.0/24",
LoggerFactory: loggerFactory,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
lan, err := vnet.NewRouter(&vnet.RouterConfig{
CIDR: "10.0.0.0/24",
@@ -191,10 +191,10 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
},
LoggerFactory: loggerFactory,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
err = wan.AddRouter(lan)
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
nw, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{localIP0, localIP1},
@@ -204,7 +204,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
}
err = lan.AddNet(nw)
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
a, err := NewAgent(&AgentConfig{
NetworkTypes: []NetworkType{
@@ -213,7 +213,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
NAT1To1IPs: []string{map0, map1},
Net: nw,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
defer a.Close() //nolint:errcheck
done := make(chan struct{})
@@ -222,17 +222,17 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
close(done)
}
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
err = a.GatherCandidates()
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
log.Debug("Wait until gathering is complete...")
<-done
log.Debug("Gathering is done")
candidates, err := a.GetLocalCandidates()
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
if len(candidates) != 2 {
t.Fatal("There must be two candidates")
@@ -274,7 +274,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
CIDR: "1.2.3.0/24",
LoggerFactory: loggerFactory,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
lan, err := vnet.NewRouter(&vnet.RouterConfig{
CIDR: "10.0.0.0/24",
@@ -286,10 +286,10 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
},
LoggerFactory: loggerFactory,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
err = wan.AddRouter(lan)
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
nw, err := vnet.NewNet(&vnet.NetConfig{
StaticIPs: []string{
@@ -301,7 +301,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
}
err = lan.AddNet(nw)
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
a, err := NewAgent(&AgentConfig{
NetworkTypes: []NetworkType{
@@ -313,7 +313,7 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
NAT1To1IPCandidateType: CandidateTypeServerReflexive,
Net: nw,
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
defer a.Close() //nolint:errcheck
done := make(chan struct{})
@@ -322,17 +322,17 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
close(done)
}
})
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
err = a.GatherCandidates()
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
log.Debug("Wait until gathering is complete...")
<-done
log.Debug("Gathering is done")
candidates, err := a.GetLocalCandidates()
assert.NoError(t, err, "should succeed")
require.NoError(t, err, "should succeed")
if len(candidates) != 2 {
t.Fatalf("Expected two candidates. actually %d", len(candidates))
@@ -352,10 +352,10 @@ func TestVNetGatherWithNAT1To1(t *testing.T) {
}
}
assert.NotNil(t, candiHost, "should not be nil")
assert.Equal(t, "10.0.0.1", candiHost.Address(), "should match")
assert.NotNil(t, candiSrflx, "should not be nil")
assert.Equal(t, "1.2.3.4", candiSrflx.Address(), "should match")
require.NotNil(t, candiHost, "should not be nil")
require.Equal(t, "10.0.0.1", candiHost.Address(), "should match")
require.NotNil(t, candiSrflx, "should not be nil")
require.Equal(t, "1.2.3.4", candiSrflx.Address(), "should match")
})
}
@@ -385,11 +385,11 @@ func TestVNetGatherWithInterfaceFilter(t *testing.T) {
a, err := NewAgent(&AgentConfig{
Net: nw,
InterfaceFilter: func(interfaceName string) bool {
assert.Equal(t, "eth0", interfaceName)
require.Equal(t, "eth0", interfaceName)
return false
},
})
assert.NoError(t, err)
require.NoError(t, err)
localIPs, err := localInterfaces(a.net, a.interfaceFilter, a.ipFilter, []NetworkType{NetworkTypeUDP4}, false)
if err != nil {
@@ -398,18 +398,18 @@ func TestVNetGatherWithInterfaceFilter(t *testing.T) {
t.Fatal("InterfaceFilter should have excluded everything")
}
assert.NoError(t, a.Close())
require.NoError(t, a.Close())
})
t.Run("IPFilter should exclude the IP", func(t *testing.T) {
a, err := NewAgent(&AgentConfig{
Net: nw,
IPFilter: func(ip net.IP) bool {
assert.Equal(t, net.IP{1, 2, 3, 1}, ip)
require.Equal(t, net.IP{1, 2, 3, 1}, ip)
return false
},
})
assert.NoError(t, err)
require.NoError(t, err)
localIPs, err := localInterfaces(a.net, a.interfaceFilter, a.ipFilter, []NetworkType{NetworkTypeUDP4}, false)
if err != nil {
@@ -418,18 +418,18 @@ func TestVNetGatherWithInterfaceFilter(t *testing.T) {
t.Fatal("IPFilter should have excluded everything")
}
assert.NoError(t, a.Close())
require.NoError(t, a.Close())
})
t.Run("InterfaceFilter should not exclude the interface", func(t *testing.T) {
a, err := NewAgent(&AgentConfig{
Net: nw,
InterfaceFilter: func(interfaceName string) bool {
assert.Equal(t, "eth0", interfaceName)
require.Equal(t, "eth0", interfaceName)
return true
},
})
assert.NoError(t, err)
require.NoError(t, err)
localIPs, err := localInterfaces(a.net, a.interfaceFilter, a.ipFilter, []NetworkType{NetworkTypeUDP4}, false)
if err != nil {
@@ -438,7 +438,7 @@ func TestVNetGatherWithInterfaceFilter(t *testing.T) {
t.Fatal("InterfaceFilter should not have excluded anything")
}
assert.NoError(t, a.Close())
require.NoError(t, a.Close())
})
}
@@ -462,9 +462,7 @@ func TestVNetGather_TURNConnectionLeak(t *testing.T) {
}
v, err := buildVNet(natType, natType)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
defer v.close()
cfg0 := &AgentConfig{
@@ -477,11 +475,9 @@ func TestVNetGather_TURNConnectionLeak(t *testing.T) {
Net: v.net0,
}
aAgent, err := NewAgent(cfg0)
if !assert.NoError(t, err, "should succeed") {
return
}
require.NoError(t, err, "should succeed")
aAgent.gatherCandidatesRelay(context.Background(), []*stun.URI{turnServerURL})
// Assert relay conn leak on close.
assert.NoError(t, aAgent.Close())
require.NoError(t, aAgent.Close())
}
ice_test.go
+3 -3
View File
@@ -6,7 +6,7 @@ package ice
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestConnectedState_String(t *testing.T) {
@@ -25,7 +25,7 @@ func TestConnectedState_String(t *testing.T) {
}
for i, testCase := range testCases {
assert.Equal(t,
require.Equal(t,
testCase.expectedString,
testCase.connectionState.String(),
"testCase: %d %v", i, testCase,
@@ -45,7 +45,7 @@ func TestGatheringState_String(t *testing.T) {
}
for i, testCase := range testCases {
assert.Equal(t,
require.Equal(t,
testCase.expectedString,
testCase.gatheringState.String(),
"testCase: %d %v", i, testCase,
mdns_test.go
+10 -10
View File
@@ -13,7 +13,7 @@ import (
"time"
"github.com/pion/transport/v3/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestMulticastDNSOnlyConnection(t *testing.T) {
@@ -54,8 +54,8 @@ func TestMulticastDNSOnlyConnection(t *testing.T) {
<-aConnected
<-bConnected
assert.NoError(t, aAgent.Close())
assert.NoError(t, bAgent.Close())
require.NoError(t, aAgent.Close())
require.NoError(t, bAgent.Close())
}
func TestMulticastDNSMixedConnection(t *testing.T) {
@@ -98,8 +98,8 @@ func TestMulticastDNSMixedConnection(t *testing.T) {
<-aConnected
<-bConnected
assert.NoError(t, aAgent.Close())
assert.NoError(t, bAgent.Close())
require.NoError(t, aAgent.Close())
require.NoError(t, bAgent.Close())
}
func TestMulticastDNSStaticHostName(t *testing.T) {
@@ -115,7 +115,7 @@ func TestMulticastDNSStaticHostName(t *testing.T) {
MulticastDNSMode: MulticastDNSModeQueryAndGather,
MulticastDNSHostName: "invalidHostName",
})
assert.Equal(t, err, ErrInvalidMulticastDNSHostName)
require.Equal(t, err, ErrInvalidMulticastDNSHostName)
agent, err := NewAgent(&AgentConfig{
NetworkTypes: []NetworkType{NetworkTypeUDP4},
@@ -123,18 +123,18 @@ func TestMulticastDNSStaticHostName(t *testing.T) {
MulticastDNSMode: MulticastDNSModeQueryAndGather,
MulticastDNSHostName: "validName.local",
})
assert.NoError(t, err)
require.NoError(t, err)
correctHostName, resolveFunc := context.WithCancel(context.Background())
assert.NoError(t, agent.OnCandidate(func(c Candidate) {
require.NoError(t, agent.OnCandidate(func(c Candidate) {
if c != nil && c.Address() == "validName.local" {
resolveFunc()
}
}))
assert.NoError(t, agent.GatherCandidates())
require.NoError(t, agent.GatherCandidates())
<-correctHostName.Done()
assert.NoError(t, agent.Close())
require.NoError(t, agent.Close())
}
func TestGenerateMulticastDNSName(t *testing.T) {
net_test.go
+5 -5
View File
@@ -7,7 +7,7 @@ import (
"net"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestIsSupportedIPv6(t *testing.T) {
@@ -37,8 +37,8 @@ func TestCreateAddr(t *testing.T) {
ipv6 := net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
port := 9000
assert.Equal(t, &net.UDPAddr{IP: ipv4, Port: port}, createAddr(NetworkTypeUDP4, ipv4, port))
assert.Equal(t, &net.UDPAddr{IP: ipv6, Port: port}, createAddr(NetworkTypeUDP6, ipv6, port))
assert.Equal(t, &net.TCPAddr{IP: ipv4, Port: port}, createAddr(NetworkTypeTCP4, ipv4, port))
assert.Equal(t, &net.TCPAddr{IP: ipv6, Port: port}, createAddr(NetworkTypeTCP6, ipv6, port))
require.Equal(t, &net.UDPAddr{IP: ipv4, Port: port}, createAddr(NetworkTypeUDP4, ipv4, port))
require.Equal(t, &net.UDPAddr{IP: ipv6, Port: port}, createAddr(NetworkTypeUDP6, ipv6, port))
require.Equal(t, &net.TCPAddr{IP: ipv4, Port: port}, createAddr(NetworkTypeTCP4, ipv4, port))
require.Equal(t, &net.TCPAddr{IP: ipv6, Port: port}, createAddr(NetworkTypeTCP6, ipv6, port))
}
networktype_test.go
+9 -9
View File
@@ -7,7 +7,7 @@ import (
"net"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNetworkTypeParsing_Success(t *testing.T) {
@@ -79,15 +79,15 @@ func TestNetworkTypeParsing_Failure(t *testing.T) {
}
func TestNetworkTypeIsUDP(t *testing.T) {
assert.True(t, NetworkTypeUDP4.IsUDP())
assert.True(t, NetworkTypeUDP6.IsUDP())
assert.False(t, NetworkTypeUDP4.IsTCP())
assert.False(t, NetworkTypeUDP6.IsTCP())
require.True(t, NetworkTypeUDP4.IsUDP())
require.True(t, NetworkTypeUDP6.IsUDP())
require.False(t, NetworkTypeUDP4.IsTCP())
require.False(t, NetworkTypeUDP6.IsTCP())
}
func TestNetworkTypeIsTCP(t *testing.T) {
assert.True(t, NetworkTypeTCP4.IsTCP())
assert.True(t, NetworkTypeTCP6.IsTCP())
assert.False(t, NetworkTypeTCP4.IsUDP())
assert.False(t, NetworkTypeTCP6.IsUDP())
require.True(t, NetworkTypeTCP4.IsTCP())
require.True(t, NetworkTypeTCP6.IsTCP())
require.False(t, NetworkTypeTCP4.IsUDP())
require.False(t, NetworkTypeTCP6.IsUDP())
}
tcp_mux_multi_test.go
+7 -8
View File
@@ -14,7 +14,6 @@ import (
"github.com/pion/logging"
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -77,9 +76,9 @@ func TestMultiTCPMux_Recv(t *testing.T) {
recv := make([]byte, n)
n2, rAddr, err := pktConn.ReadFrom(recv)
require.NoError(t, err, "error receiving data")
assert.Equal(t, conn.LocalAddr(), rAddr, "remote TCP address mismatch")
assert.Equal(t, n, n2, "received byte size mismatch")
assert.Equal(t, msg.Raw, recv, "received bytes mismatch")
require.Equal(t, conn.LocalAddr(), rAddr, "remote TCP address mismatch")
require.Equal(t, n, n2, "received byte size mismatch")
require.Equal(t, msg.Raw, recv, "received bytes mismatch")
// Check echo response
n, err = pktConn.WriteTo(recv, conn.LocalAddr())
@@ -87,8 +86,8 @@ func TestMultiTCPMux_Recv(t *testing.T) {
recvEcho := make([]byte, n)
n3, err := readStreamingPacket(conn, recvEcho)
require.NoError(t, err, "error receiving echo data")
assert.Equal(t, n2, n3, "received byte size mismatch")
assert.Equal(t, msg.Raw, recvEcho, "received bytes mismatch")
require.Equal(t, n2, n3, "received byte size mismatch")
require.Equal(t, msg.Raw, recvEcho, "received bytes mismatch")
}
})
}
@@ -126,6 +125,6 @@ func TestMultiTCPMux_NoDeadlockWhenClosingUnusedPacketConn(t *testing.T) {
require.NoError(t, muxMulti.Close(), "error closing tcpMux")
conn, err := muxMulti.GetAllConns("test", false, net.IP{127, 0, 0, 1})
assert.Nil(t, conn, "should receive nil because mux is closed")
assert.Equal(t, io.ErrClosedPipe, err, "should receive error because mux is closed")
require.Nil(t, conn, "should receive nil because mux is closed")
require.Equal(t, io.ErrClosedPipe, err, "should receive error because mux is closed")
}
tcp_mux_test.go
+10 -11
View File
@@ -13,7 +13,6 @@ import (
"github.com/pion/logging"
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -73,9 +72,9 @@ func TestTCPMux_Recv(t *testing.T) {
recv := make([]byte, n)
n2, rAddr, err := pktConn.ReadFrom(recv)
require.NoError(t, err, "error receiving data")
assert.Equal(t, conn.LocalAddr(), rAddr, "remote tcp address mismatch")
assert.Equal(t, n, n2, "received byte size mismatch")
assert.Equal(t, msg.Raw, recv, "received bytes mismatch")
require.Equal(t, conn.LocalAddr(), rAddr, "remote tcp address mismatch")
require.Equal(t, n, n2, "received byte size mismatch")
require.Equal(t, msg.Raw, recv, "received bytes mismatch")
// Check echo response
n, err = pktConn.WriteTo(recv, conn.LocalAddr())
@@ -83,8 +82,8 @@ func TestTCPMux_Recv(t *testing.T) {
recvEcho := make([]byte, n)
n3, err := readStreamingPacket(conn, recvEcho)
require.NoError(t, err, "error receiving echo data")
assert.Equal(t, n2, n3, "received byte size mismatch")
assert.Equal(t, msg.Raw, recvEcho, "received bytes mismatch")
require.Equal(t, n2, n3, "received byte size mismatch")
require.Equal(t, msg.Raw, recvEcho, "received bytes mismatch")
})
}
}
@@ -120,8 +119,8 @@ func TestTCPMux_NoDeadlockWhenClosingUnusedPacketConn(t *testing.T) {
require.NoError(t, tcpMux.Close(), "error closing tcpMux")
conn, err := tcpMux.GetConnByUfrag("test", false, listener.Addr().(*net.TCPAddr).IP)
assert.Nil(t, conn, "should receive nil because mux is closed")
assert.Equal(t, io.ErrClosedPipe, err, "should receive error because mux is closed")
require.Nil(t, conn, "should receive nil because mux is closed")
require.Equal(t, io.ErrClosedPipe, err, "should receive error because mux is closed")
}
func TestTCPMux_FirstPacketTimeout(t *testing.T) {
@@ -253,8 +252,8 @@ func TestTCPMux_NoLeakForConnectionFromStun(t *testing.T) {
recv := make([]byte, n)
n2, rAddr, err := pktConn.ReadFrom(recv)
require.NoError(t, err, "error receiving data")
assert.Equal(t, conn.LocalAddr(), rAddr, "remote tcp address mismatch")
assert.Equal(t, n, n2, "received byte size mismatch")
assert.Equal(t, msg.Raw, recv, "received bytes mismatch")
require.Equal(t, conn.LocalAddr(), rAddr, "remote tcp address mismatch")
require.Equal(t, n, n2, "received byte size mismatch")
require.Equal(t, msg.Raw, recv, "received bytes mismatch")
})
}
tcptype_test.go
+11 -11
View File
@@ -6,21 +6,21 @@ package ice
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestTCPType(t *testing.T) {
var tcpType TCPType
assert.Equal(t, TCPTypeUnspecified, tcpType)
assert.Equal(t, TCPTypeActive, NewTCPType("active"))
assert.Equal(t, TCPTypePassive, NewTCPType("passive"))
assert.Equal(t, TCPTypeSimultaneousOpen, NewTCPType("so"))
assert.Equal(t, TCPTypeUnspecified, NewTCPType("something else"))
require.Equal(t, TCPTypeUnspecified, tcpType)
require.Equal(t, TCPTypeActive, NewTCPType("active"))
require.Equal(t, TCPTypePassive, NewTCPType("passive"))
require.Equal(t, TCPTypeSimultaneousOpen, NewTCPType("so"))
require.Equal(t, TCPTypeUnspecified, NewTCPType("something else"))
assert.Equal(t, "", TCPTypeUnspecified.String())
assert.Equal(t, "active", TCPTypeActive.String())
assert.Equal(t, "passive", TCPTypePassive.String())
assert.Equal(t, "so", TCPTypeSimultaneousOpen.String())
assert.Equal(t, "Unknown", TCPType(-1).String())
require.Equal(t, "", TCPTypeUnspecified.String())
require.Equal(t, "active", TCPTypeActive.String())
require.Equal(t, "passive", TCPTypePassive.String())
require.Equal(t, "so", TCPTypeSimultaneousOpen.String())
require.Equal(t, "Unknown", TCPType(-1).String())
}
transport_vnet_test.go
+16 -18
View File
@@ -15,7 +15,7 @@ import (
"github.com/pion/stun/v2"
"github.com/pion/transport/v3/test"
"github.com/pion/transport/v3/vnet"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRemoteLocalAddr(t *testing.T) {
@@ -33,9 +33,7 @@ func TestRemoteLocalAddr(t *testing.T) {
natType1 := &vnet.NATType{Mode: vnet.NATModeNAT1To1}
v, errVnet := buildVNet(natType0, natType1)
if !assert.NoError(t, errVnet, "should succeed") {
return
}
require.NoError(t, errVnet, "should succeed")
defer v.close()
stunServerURL := &stun.URI{
@@ -47,13 +45,13 @@ func TestRemoteLocalAddr(t *testing.T) {
t.Run("Disconnected Returns nil", func(t *testing.T) {
disconnectedAgent, err := NewAgent(&AgentConfig{})
assert.NoError(t, err)
require.NoError(t, err)
disconnectedConn := Conn{agent: disconnectedAgent}
assert.Nil(t, disconnectedConn.RemoteAddr())
assert.Nil(t, disconnectedConn.LocalAddr())
require.Nil(t, disconnectedConn.RemoteAddr())
require.Nil(t, disconnectedConn.LocalAddr())
assert.NoError(t, disconnectedConn.Close())
require.NoError(t, disconnectedConn.Close())
})
t.Run("Remote/Local Pair Match between Agents", func(t *testing.T) {
@@ -72,27 +70,27 @@ func TestRemoteLocalAddr(t *testing.T) {
bLAddr := cb.LocalAddr()
// Assert that nothing is nil
assert.NotNil(t, aRAddr)
assert.NotNil(t, aLAddr)
assert.NotNil(t, bRAddr)
assert.NotNil(t, bLAddr)
require.NotNil(t, aRAddr)
require.NotNil(t, aLAddr)
require.NotNil(t, bRAddr)
require.NotNil(t, bLAddr)
// Assert addresses
assert.Equal(t, aLAddr.String(),
require.Equal(t, aLAddr.String(),
fmt.Sprintf("%s:%d", vnetLocalIPA, bRAddr.(*net.UDPAddr).Port), //nolint:forcetypeassert
)
assert.Equal(t, bLAddr.String(),
require.Equal(t, bLAddr.String(),
fmt.Sprintf("%s:%d", vnetLocalIPB, aRAddr.(*net.UDPAddr).Port), //nolint:forcetypeassert
)
assert.Equal(t, aRAddr.String(),
require.Equal(t, aRAddr.String(),
fmt.Sprintf("%s:%d", vnetGlobalIPB, bLAddr.(*net.UDPAddr).Port), //nolint:forcetypeassert
)
assert.Equal(t, bRAddr.String(),
require.Equal(t, bRAddr.String(),
fmt.Sprintf("%s:%d", vnetGlobalIPA, aLAddr.(*net.UDPAddr).Port), //nolint:forcetypeassert
)
// Close
assert.NoError(t, ca.Close())
assert.NoError(t, cb.Close())
require.NoError(t, ca.Close())
require.NoError(t, cb.Close())
})
}