package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 23:26:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

simplify tests (#245)

Browse Source
This commit is contained in:
Alessandro Ros
2023-04-13 12:01:57 +02:00
committed by GitHub
parent 7bf71a18b3
commit 1f19f3cdb8
4 changed files with 371 additions and 833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -6,7 +6,7 @@
[![CodeCov](https://codecov.io/gh/bluenviron/gortsplib/branch/main/graph/badge.svg)](https://app.codecov.io/gh/bluenviron/gortsplib/branch/main) [![CodeCov](https://codecov.io/gh/bluenviron/gortsplib/branch/main/graph/badge.svg)](https://app.codecov.io/gh/bluenviron/gortsplib/branch/main)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/bluenviron/gortsplib/v3)](https://pkg.go.dev/github.com/bluenviron/gortsplib/v3#pkg-index) [![PkgGoDev](https://pkg.go.dev/badge/github.com/bluenviron/gortsplib/v3)](https://pkg.go.dev/github.com/bluenviron/gortsplib/v3#pkg-index)
RTSP 1.0 client and server library for the Go programming language, written for [rtsp-simple-server](https://github.com/aler9/rtsp-simple-server). RTSP 1.0 client and server library for the Go programming language, written for [MediaMTX](https://github.com/aler9/mediamtx).
Go ≥ 1.18 is required. Go ≥ 1.18 is required.

649
server_play_test.go
View File

@@ -3,7 +3,6 @@ package gortsplib
import ( import (
"bytes" "bytes"
"crypto/tls" "crypto/tls"
"errors"
"net" "net"
"strconv" "strconv"
"strings" "strings"
@@ -63,7 +62,7 @@ func absoluteControlAttribute(md *psdp.MediaDescription) string {
return v return v
} }
func doDescribe(conn *conn.Conn) (*sdp.SessionDescription, error) { func doDescribe(t *testing.T, conn *conn.Conn) *sdp.SessionDescription {
res, err := writeReqReadRes(conn, base.Request{ res, err := writeReqReadRes(conn, base.Request{
Method: base.Describe, Method: base.Describe,
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
@@ -71,21 +70,65 @@ func doDescribe(conn *conn.Conn) (*sdp.SessionDescription, error) {
"CSeq": base.HeaderValue{"1"}, "CSeq": base.HeaderValue{"1"},
}, },
}) })
if err != nil { require.NoError(t, err)
return nil, err require.Equal(t, base.StatusOK, res.StatusCode)
}
if res.StatusCode != base.StatusOK {
return nil, errors.New("bad status code")
}
var desc sdp.SessionDescription var desc sdp.SessionDescription
err = desc.Unmarshal(res.Body) err = desc.Unmarshal(res.Body)
if err != nil { require.NoError(t, err)
return nil, err return &desc
} }
return &desc, err func doSetup(t *testing.T, conn *conn.Conn, u string, inTH *headers.Transport) (*base.Response, *headers.Transport) {
res, err := writeReqReadRes(conn, base.Request{
Method: base.Setup,
URL: mustParseURL(u),
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var th headers.Transport
err = th.Unmarshal(res.Header["Transport"])
require.NoError(t, err)
return res, &th
}
func doPlay(t *testing.T, conn *conn.Conn, u string, session string) {
res, err := writeReqReadRes(conn, base.Request{
Method: base.Play,
URL: mustParseURL(u),
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
"Session": base.HeaderValue{session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
}
func doPause(t *testing.T, conn *conn.Conn, u string, session string) {
res, err := writeReqReadRes(conn, base.Request{
Method: base.Pause,
URL: mustParseURL(u),
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
"Session": base.HeaderValue{session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
}
func readSession(t *testing.T, res *base.Response) string {
var sx headers.Session
err := sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
return sx.Session
} }
func TestServerPlayPath(t *testing.T) { func TestServerPlayPath(t *testing.T) {
@@ -188,8 +231,7 @@ func TestServerPlayPath(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
th := &headers.Transport{ th := &headers.Transport{
Protocol: headers.TransportProtocolTCP, Protocol: headers.TransportProtocolTCP,
@@ -204,32 +246,14 @@ func TestServerPlayPath(t *testing.T) {
InterleavedIDs: &[2]int{0, 1}, InterleavedIDs: &[2]int{0, 1},
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn,
Method: base.Setup, strings.ReplaceAll(ca.setupURL, "[control]", "/"+
URL: mustParseURL(strings.ReplaceAll(ca.setupURL, "[control]", "/"+ relativeControlAttribute(desc.MediaDescriptions[1])),
relativeControlAttribute(desc.MediaDescriptions[1]))), th)
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": th.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, ca.playURL, session)
Method: base.Play,
URL: mustParseURL(ca.playURL),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
}) })
} }
} }
@@ -288,8 +312,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
th := &headers.Transport{ th := &headers.Transport{
Protocol: headers.TransportProtocolTCP, Protocol: headers.TransportProtocolTCP,
@@ -318,9 +341,8 @@ func TestServerPlaySetupErrors(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
th.InterleavedIDs = &[2]int{2, 3} th.InterleavedIDs = &[2]int{2, 3}
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
@@ -329,7 +351,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Transport": th.Marshal(), "Transport": th.Marshal(),
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -339,9 +361,8 @@ func TestServerPlaySetupErrors(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
th.InterleavedIDs = &[2]int{2, 3} th.InterleavedIDs = &[2]int{2, 3}
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
@@ -350,7 +371,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"4"}, "CSeq": base.HeaderValue{"4"},
"Transport": th.Marshal(), "Transport": th.Marshal(),
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -425,8 +446,7 @@ func TestServerPlaySetupErrorSameUDPPortsAndIP(t *testing.T) {
ClientPorts: &[2]int{35466, 35467}, ClientPorts: &[2]int{35466, 35467},
} }
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ res, err := writeReqReadRes(conn, base.Request{
Method: base.Setup, Method: base.Setup,
@@ -566,8 +586,7 @@ func TestServerPlay(t *testing.T) {
<-nconnOpened <-nconnOpened
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Mode: func() *headers.TransportMode { Mode: func() *headers.TransportMode {
@@ -595,20 +614,7 @@ func TestServerPlay(t *testing.T) {
inTH.InterleavedIDs = &[2]int{4, 5} inTH.InterleavedIDs = &[2]int{4, 5}
} }
res, err := writeReqReadRes(conn, base.Request{ res, th := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var th headers.Transport
err = th.Unmarshal(res.Header["Transport"])
require.NoError(t, err)
var l1 net.PacketConn var l1 net.PacketConn
var l2 net.PacketConn var l2 net.PacketConn
@@ -665,20 +671,9 @@ func TestServerPlay(t *testing.T) {
<-sessionOpened <-sessionOpened
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://"+listenIP+":8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
// server -> client (direct) // server -> client (direct)
switch transport { switch transport {
@@ -765,7 +760,7 @@ func TestServerPlay(t *testing.T) {
URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"), URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"4"}, "CSeq": base.HeaderValue{"4"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -777,7 +772,7 @@ func TestServerPlay(t *testing.T) {
URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"), URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"5"}, "CSeq": base.HeaderValue{"5"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -789,7 +784,7 @@ func TestServerPlay(t *testing.T) {
URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"), URL: mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"6"}, "CSeq": base.HeaderValue{"6"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -867,8 +862,7 @@ func TestServerPlayDecodeErrors(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Mode: func() *headers.TransportMode { Mode: func() *headers.TransportMode {
@@ -889,20 +883,7 @@ func TestServerPlayDecodeErrors(t *testing.T) {
inTH.InterleavedIDs = &[2]int{0, 1} inTH.InterleavedIDs = &[2]int{0, 1}
} }
res, err := writeReqReadRes(conn, base.Request{ res, resTH := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var resTH headers.Transport
err = resTH.Unmarshal(res.Header["Transport"])
require.NoError(t, err)
var l1 net.PacketConn var l1 net.PacketConn
var l2 net.PacketConn var l2 net.PacketConn
@@ -917,20 +898,9 @@ func TestServerPlayDecodeErrors(t *testing.T) {
defer l2.Close() defer l2.Close()
} }
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
switch { //nolint:dupl switch { //nolint:dupl
case ca.proto == "udp" && ca.name == "rtcp invalid": case ca.proto == "udp" && ca.name == "rtcp invalid":
@@ -1004,8 +974,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Mode: func() *headers.TransportMode { Mode: func() *headers.TransportMode {
@@ -1026,16 +995,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
inTH.InterleavedIDs = &[2]int{0, 1} inTH.InterleavedIDs = &[2]int{0, 1}
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var l1 net.PacketConn var l1 net.PacketConn
var l2 net.PacketConn var l2 net.PacketConn
@@ -1049,20 +1009,9 @@ func TestServerPlayRTCPReport(t *testing.T) {
defer l2.Close() defer l2.Close()
} }
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
stream.WritePacketRTP(stream.Medias()[0], &rtp.Packet{ stream.WritePacketRTP(stream.Medias()[0], &rtp.Packet{
@@ -1110,7 +1059,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"4"}, "CSeq": base.HeaderValue{"4"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1226,45 +1175,26 @@ func TestServerPlayTCPResponseBeforeFrames(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"), doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
_, err = conn.ReadInterleavedFrame() _, err = conn.ReadInterleavedFrame()
require.NoError(t, err) require.NoError(t, err)
@@ -1306,56 +1236,27 @@ func TestServerPlayPlayPlay(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolUDP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolUDP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), ClientPorts: &[2]int{30450, 30451},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
ClientPorts: &[2]int{30450, 30451},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play, doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"4"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
} }
func TestServerPlayPlayPausePlay(t *testing.T) { func TestServerPlayPlayPausePlay(t *testing.T) {
@@ -1424,67 +1325,28 @@ func TestServerPlayPlayPausePlay(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Pause, doPause(t, conn, "rtsp://localhost:8554/teststream", session)
URL: mustParseURL("rtsp://localhost:8554/teststream"), doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
res, err = writeReqReadRes(conn, base.Request{
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
} }
func TestServerPlayPlayPausePause(t *testing.T) { func TestServerPlayPlayPausePause(t *testing.T) {
@@ -1549,73 +1411,30 @@ func TestServerPlayPlayPausePause(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
err = conn.WriteRequest(&base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Pause,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"4"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
res, err = conn.ReadResponseIgnoreFrames() doPause(t, conn, "rtsp://localhost:8554/teststream", session)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
err = conn.WriteRequest(&base.Request{ doPause(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Pause,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"5"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
res, err = conn.ReadResponseIgnoreFrames()
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
} }
func TestServerPlayTimeout(t *testing.T) { func TestServerPlayTimeout(t *testing.T) {
@@ -1677,8 +1496,7 @@ func TestServerPlayTimeout(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Mode: func() *headers.TransportMode { Mode: func() *headers.TransportMode {
@@ -1700,31 +1518,11 @@ func TestServerPlayTimeout(t *testing.T) {
inTH.Protocol = headers.TransportProtocolUDP inTH.Protocol = headers.TransportProtocolUDP
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
<-sessionClosed <-sessionClosed
}) })
@@ -1786,8 +1584,7 @@ func TestServerPlayWithoutTeardown(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Delivery: func() *headers.TransportDelivery { Delivery: func() *headers.TransportDelivery {
@@ -1808,31 +1605,11 @@ func TestServerPlayWithoutTeardown(t *testing.T) {
inTH.InterleavedIDs = &[2]int{0, 1} inTH.InterleavedIDs = &[2]int{0, 1}
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
nconn.Close() nconn.Close()
@@ -1886,8 +1663,7 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Delivery: func() *headers.TransportDelivery { Delivery: func() *headers.TransportDelivery {
@@ -1902,33 +1678,13 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
ClientPorts: &[2]int{35466, 35467}, ClientPorts: &[2]int{35466, 35467},
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
sxID = sx.Session sxID = session
}() }()
func() { func() {
@@ -1990,8 +1746,7 @@ func TestServerPlayPartialMedias(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Delivery: func() *headers.TransportDelivery { Delivery: func() *headers.TransportDelivery {
@@ -2006,31 +1761,11 @@ func TestServerPlayPartialMedias(t *testing.T) {
InterleavedIDs: &[2]int{4, 5}, InterleavedIDs: &[2]int{4, 5},
} }
res, err := writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[1])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
f, err := conn.ReadInterleavedFrame() f, err := conn.ReadInterleavedFrame()
require.NoError(t, err) require.NoError(t, err)
@@ -2045,8 +1780,7 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTH := &headers.Transport{ inTH := &headers.Transport{
Delivery: func() *headers.TransportDelivery { Delivery: func() *headers.TransportDelivery {
@@ -2061,20 +1795,8 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
InterleavedIDs: &[2]int{0, 1}, InterleavedIDs: &[2]int{0, 1},
} }
res, err := writeReqReadRes(conn, base.Request{ res, th := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var th headers.Transport
err = th.Unmarshal(res.Header["Transport"])
require.NoError(t, err)
ssrcs := make([]*uint32, 2) ssrcs := make([]*uint32, 2)
ssrcs[0] = th.SSRC ssrcs[0] = th.SSRC
@@ -2091,9 +1813,7 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
InterleavedIDs: &[2]int{2, 3}, InterleavedIDs: &[2]int{2, 3},
} }
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Setup, Method: base.Setup,
@@ -2101,27 +1821,18 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Transport": inTH.Marshal(), "Transport": inTH.Marshal(),
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
th = headers.Transport{} th = &headers.Transport{}
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
require.NoError(t, err) require.NoError(t, err)
ssrcs[1] = th.SSRC ssrcs[1] = th.SSRC
res, err = writeReqReadRes(conn, base.Request{ doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"4"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var ri headers.RTPInfo var ri headers.RTPInfo
err = ri.Unmarshal(res.Header["RTP-Info"]) err = ri.Unmarshal(res.Header["RTP-Info"])

225
server_record_test.go
View File

@@ -276,27 +276,16 @@ func TestServerRecordPath(t *testing.T) {
InterleavedIDs: &[2]int{0, 1}, InterleavedIDs: &[2]int{0, 1},
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, ca.setupURL, th)
Method: base.Setup,
URL: mustParseURL(ca.setupURL),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": th.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Record, Method: base.Record,
URL: mustParseURL(ca.announceURL), URL: mustParseURL(ca.announceURL),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -351,31 +340,22 @@ func TestServerRecordErrorSetupMediaTwice(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
res, err = writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModeRecord
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModeRecord
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err) session := readSession(t, res)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Setup, Method: base.Setup,
@@ -394,7 +374,7 @@ func TestServerRecordErrorSetupMediaTwice(t *testing.T) {
}(), }(),
InterleavedIDs: &[2]int{2, 3}, InterleavedIDs: &[2]int{2, 3},
}.Marshal(), }.Marshal(),
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -471,7 +451,7 @@ func TestServerRecordErrorRecordPartialMedias(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
th := &headers.Transport{ inTH := &headers.Transport{
Protocol: headers.TransportProtocolTCP, Protocol: headers.TransportProtocolTCP,
Delivery: func() *headers.TransportDelivery { Delivery: func() *headers.TransportDelivery {
v := headers.TransportDeliveryUnicast v := headers.TransportDeliveryUnicast
@@ -484,27 +464,16 @@ func TestServerRecordErrorRecordPartialMedias(t *testing.T) {
InterleavedIDs: &[2]int{0, 1}, InterleavedIDs: &[2]int{0, 1},
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": th.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Record, Method: base.Record,
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -648,7 +617,7 @@ func TestServerRecord(t *testing.T) {
var l1s [2]net.PacketConn var l1s [2]net.PacketConn
var l2s [2]net.PacketConn var l2s [2]net.PacketConn
var sx headers.Session var session string
var serverPorts [2]*[2]int var serverPorts [2]*[2]int
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
@@ -679,19 +648,9 @@ func TestServerRecord(t *testing.T) {
inTH.InterleavedIDs = &[2]int{2 + i*2, 3 + i*2} inTH.InterleavedIDs = &[2]int{2 + i*2, 3 + i*2}
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ := doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[i].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[i].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
err = sx.Unmarshal(res.Header["Session"]) session = readSession(t, res)
require.NoError(t, err)
var th headers.Transport var th headers.Transport
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
@@ -707,7 +666,7 @@ func TestServerRecord(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -780,7 +739,7 @@ func TestServerRecord(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -861,20 +820,9 @@ func TestServerRecordErrorInvalidProtocol(t *testing.T) {
ClientPorts: &[2]int{35466, 35467}, ClientPorts: &[2]int{35466, 35467},
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
var th headers.Transport var th headers.Transport
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
@@ -885,7 +833,7 @@ func TestServerRecordErrorInvalidProtocol(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -957,31 +905,22 @@ func TestServerRecordRTCPReport(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer l2.Close() defer l2.Close()
res, err = writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Delivery: func() *headers.TransportDelivery {
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control), v := headers.TransportDeliveryUnicast
Header: base.Header{ return &v
"CSeq": base.HeaderValue{"2"}, }(),
"Transport": headers.Transport{ Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModeRecord
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), Protocol: headers.TransportProtocolUDP,
Mode: func() *headers.TransportMode { ClientPorts: &[2]int{34556, 34557},
v := headers.TransportModeRecord }
return &v
}(),
Protocol: headers.TransportProtocolUDP,
ClientPorts: &[2]int{34556, 34557},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err) session := readSession(t, res)
var th headers.Transport var th headers.Transport
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
@@ -992,7 +931,7 @@ func TestServerRecordRTCPReport(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1143,20 +1082,9 @@ func TestServerRecordTimeout(t *testing.T) {
inTH.InterleavedIDs = &[2]int{0, 1} inTH.InterleavedIDs = &[2]int{0, 1}
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
var th headers.Transport var th headers.Transport
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
@@ -1167,7 +1095,7 @@ func TestServerRecordTimeout(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1266,20 +1194,9 @@ func TestServerRecordWithoutTeardown(t *testing.T) {
inTH.InterleavedIDs = &[2]int{0, 1} inTH.InterleavedIDs = &[2]int{0, 1}
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
var th headers.Transport var th headers.Transport
err = th.Unmarshal(res.Header["Transport"]) err = th.Unmarshal(res.Header["Transport"])
@@ -1290,7 +1207,7 @@ func TestServerRecordWithoutTeardown(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -1373,33 +1290,22 @@ func TestServerRecordUDPChangeConn(t *testing.T) {
ClientPorts: &[2]int{35466, 35467}, ClientPorts: &[2]int{35466, 35467},
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Record, Method: base.Record,
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode) require.Equal(t, base.StatusOK, res.StatusCode)
sxID = sx.Session sxID = session
}() }()
func() { func() {
@@ -1550,20 +1456,9 @@ func TestServerRecordDecodeErrors(t *testing.T) {
defer l2.Close() defer l2.Close()
} }
res, err = writeReqReadRes(conn, base.Request{ res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
Method: base.Setup,
URL: mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": inTH.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session session := readSession(t, res)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
var resTH headers.Transport var resTH headers.Transport
err = resTH.Unmarshal(res.Header["Transport"]) err = resTH.Unmarshal(res.Header["Transport"])
@@ -1574,7 +1469,7 @@ func TestServerRecordDecodeErrors(t *testing.T) {
URL: mustParseURL("rtsp://localhost:8554/teststream"), URL: mustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)

328
server_test.go
View File

@@ -358,42 +358,34 @@ func TestServerErrorMethodNotImplemented(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
var sx headers.Session var session string
if ca == "inside session" { if ca == "inside session" {
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"1"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
err = sx.Unmarshal(res.Header["Session"]) res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
require.NoError(t, err)
session = readSession(t, res)
} }
headers := base.Header{ headers := base.Header{
"CSeq": base.HeaderValue{"2"}, "CSeq": base.HeaderValue{"2"},
} }
if ca == "inside session" { if ca == "inside session" {
headers["Session"] = base.HeaderValue{sx.Session} headers["Session"] = base.HeaderValue{session}
} }
res, err := writeReqReadRes(conn, base.Request{ res, err := writeReqReadRes(conn, base.Request{
@@ -408,7 +400,7 @@ func TestServerErrorMethodNotImplemented(t *testing.T) {
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
} }
if ca == "inside session" { if ca == "inside session" {
headers["Session"] = base.HeaderValue{sx.Session} headers["Session"] = base.HeaderValue{session}
} }
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
@@ -461,53 +453,33 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
defer nconn1.Close() defer nconn1.Close()
conn1 := conn.NewConn(nconn1) conn1 := conn.NewConn(nconn1)
desc1, err := doDescribe(conn1) desc1 := doDescribe(t, conn1)
require.NoError(t, err)
res, err := writeReqReadRes(conn1, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc1.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"1"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn1, absoluteControlAttribute(desc1.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn1, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"), doPlay(t, conn1, "rtsp://localhost:8554/teststream", session)
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
nconn2, err := net.Dial("tcp", "localhost:8554") nconn2, err := net.Dial("tcp", "localhost:8554")
require.NoError(t, err) require.NoError(t, err)
defer nconn2.Close() defer nconn2.Close()
conn2 := conn.NewConn(nconn2) conn2 := conn.NewConn(nconn2)
desc2, err := doDescribe(conn2) desc2 := doDescribe(t, conn2)
require.NoError(t, err)
res, err = writeReqReadRes(conn2, base.Request{ res, err = writeReqReadRes(conn2, base.Request{
Method: base.Setup, Method: base.Setup,
@@ -526,7 +498,7 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
}(), }(),
InterleavedIDs: &[2]int{0, 1}, InterleavedIDs: &[2]int{0, 1},
}.Marshal(), }.Marshal(),
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -572,45 +544,26 @@ func TestServerErrorTCPOneConnTwoSessions(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"1"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err)
res, err = writeReqReadRes(conn, base.Request{ session := readSession(t, res)
Method: base.Play,
URL: mustParseURL("rtsp://localhost:8554/teststream"), doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session},
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Setup, Method: base.Setup,
@@ -664,8 +617,7 @@ func TestServerSetupMultipleTransports(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
inTHS := headers.Transports{ inTHS := headers.Transports{
{ {
@@ -775,43 +727,34 @@ func TestServerGetSetParameter(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
var sx headers.Session var session string
if ca == "inside session" { if ca == "inside session" {
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"2"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
err = sx.Unmarshal(res.Header["Session"]) res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
require.NoError(t, err)
session = readSession(t, res)
} }
headers := base.Header{ headers := base.Header{
"CSeq": base.HeaderValue{"3"}, "CSeq": base.HeaderValue{"3"},
} }
if ca == "inside session" { if ca == "inside session" {
headers["Session"] = base.HeaderValue{sx.Session} headers["Session"] = base.HeaderValue{session}
} }
res, err := writeReqReadRes(conn, base.Request{ res, err := writeReqReadRes(conn, base.Request{
@@ -827,7 +770,7 @@ func TestServerGetSetParameter(t *testing.T) {
"CSeq": base.HeaderValue{"4"}, "CSeq": base.HeaderValue{"4"},
} }
if ca == "inside session" { if ca == "inside session" {
headers["Session"] = base.HeaderValue{sx.Session} headers["Session"] = base.HeaderValue{session}
} }
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
@@ -929,30 +872,22 @@ func TestServerSessionClose(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"1"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
session.Close() session.Close()
session.Close() session.Close()
@@ -1010,30 +945,37 @@ func TestServerSessionAutoClose(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
_, err = writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Protocol: headers.TransportProtocolTCP,
Delivery: func() *headers.TransportDelivery {
v := headers.TransportDeliveryUnicast
return &v
}(),
Mode: func() *headers.TransportMode {
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}
res, err := writeReqReadRes(conn, base.Request{
Method: base.Setup, Method: base.Setup,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"1"}, "CSeq": base.HeaderValue{"1"},
"Transport": headers.Transport{ "Transport": inTH.Marshal(),
Protocol: headers.TransportProtocolTCP,
Delivery: func() *headers.TransportDelivery {
v := headers.TransportDeliveryUnicast
return &v
}(),
Mode: func() *headers.TransportMode {
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
}, },
}) })
require.NoError(t, err) require.NoError(t, err)
if ca == "200" {
require.Equal(t, base.StatusOK, res.StatusCode)
} else {
require.Equal(t, base.StatusBadRequest, res.StatusCode)
}
nconn.Close() nconn.Close()
<-sessionClosed <-sessionClosed
@@ -1070,41 +1012,31 @@ func TestServerSessionTeardown(t *testing.T) {
defer nconn.Close() defer nconn.Close()
conn := conn.NewConn(nconn) conn := conn.NewConn(nconn)
desc, err := doDescribe(conn) desc := doDescribe(t, conn)
require.NoError(t, err)
res, err := writeReqReadRes(conn, base.Request{ inTH := &headers.Transport{
Method: base.Setup, Protocol: headers.TransportProtocolTCP,
URL: mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])), Delivery: func() *headers.TransportDelivery {
Header: base.Header{ v := headers.TransportDeliveryUnicast
"CSeq": base.HeaderValue{"1"}, return &v
"Transport": headers.Transport{ }(),
Protocol: headers.TransportProtocolTCP, Mode: func() *headers.TransportMode {
Delivery: func() *headers.TransportDelivery { v := headers.TransportModePlay
v := headers.TransportDeliveryUnicast return &v
return &v }(),
}(), InterleavedIDs: &[2]int{0, 1},
Mode: func() *headers.TransportMode { }
v := headers.TransportModePlay
return &v
}(),
InterleavedIDs: &[2]int{0, 1},
}.Marshal(),
},
})
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
var sx headers.Session res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
err = sx.Unmarshal(res.Header["Session"])
require.NoError(t, err) session := readSession(t, res)
res, err = writeReqReadRes(conn, base.Request{ res, err = writeReqReadRes(conn, base.Request{
Method: base.Teardown, Method: base.Teardown,
URL: mustParseURL("rtsp://localhost:8554/"), URL: mustParseURL("rtsp://localhost:8554/"),
Header: base.Header{ Header: base.Header{
"CSeq": base.HeaderValue{"2"}, "CSeq": base.HeaderValue{"2"},
"Session": base.HeaderValue{sx.Session}, "Session": base.HeaderValue{session},
}, },
}) })
require.NoError(t, err) require.NoError(t, err)