mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-04 20:57:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

use a connection in the Client

Browse source
This commit is contained in:
Marten Seemann 2017-02-19 14:29:00 +07:00
parent d61c0eb85d
commit af4b36b002
No known key found for this signature in database
GPG key ID: 3603F40B121FCDEA
4 changed files with 52 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

92
client_test.go
View file

@ -21,10 +21,12 @@ var _ = Describe("Client", func() {
var (
client *Client
sess *mockSession
packetConn *mockPacketConn
versionNegotiateCallbackCalled bool
)
BeforeEach(func() {
packetConn = &mockPacketConn{}
versionNegotiateCallbackCalled = false
client = &Client{
versionNegotiateCallback: func() error {
@ -32,20 +34,14 @@ var _ = Describe("Client", func() {
return nil
},
}
addr := &net.UDPAddr{IP: net.IPv4(192, 168, 100, 200), Port: 1337}
sess = &mockSession{connectionID: 0x1337}
client.connectionID = 0x1337
client.session = sess
client.version = protocol.Version36
client.conn = &conn{pconn: packetConn, currentAddr: addr}
})
startUDPConn := func() {
var err error
client.addr, err = net.ResolveUDPAddr("udp", "127.0.0.1:0")
Expect(err).ToNot(HaveOccurred())
client.conn, err = net.ListenUDP("udp", client.addr)
Expect(err).NotTo(HaveOccurred())
}
It("creates a new client", func() {
var err error
client, err = NewClient("quic.clemente.io:1337", nil, nil, nil)
@ -55,27 +51,28 @@ var _ = Describe("Client", func() {
})
It("errors on invalid public header", func() {
err := client.handlePacket(nil)
err := client.handlePacket(nil, nil)
Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(qerr.InvalidPacketHeader))
})
It("errors on large packets", func() {
err := client.handlePacket(bytes.Repeat([]byte{'a'}, int(protocol.MaxPacketSize)+1))
err := client.handlePacket(nil, bytes.Repeat([]byte{'a'}, int(protocol.MaxPacketSize)+1))
Expect(err).To(MatchError(qerr.PacketTooLarge))
})
It("properly closes the client", func(done Done) {
PIt("properly closes the client", func(done Done) {
testErr := errors.New("test error")
time.Sleep(10 * time.Millisecond) // Wait for old goroutines to finish
numGoRoutines := runtime.NumGoroutine()
startUDPConn()
var stoppedListening bool
go func() {
defer GinkgoRecover()
err := client.Listen()
Expect(err).ToNot(HaveOccurred())
stoppedListening = true
}()
testErr := errors.New("test error")
err := client.Close(testErr)
Expect(err).ToNot(HaveOccurred())
Eventually(sess.closed).Should(BeTrue())
@ -84,7 +81,7 @@ var _ = Describe("Client", func() {
Eventually(func() bool { return stoppedListening }).Should(BeTrue())
Eventually(runtime.NumGoroutine()).Should(Equal(numGoRoutines))
close(done)
})
}, 10)
It("only closes the client once", func() {
client.closed = 1
@ -95,7 +92,6 @@ var _ = Describe("Client", func() {
})
It("creates new sessions with the right parameters", func() {
startUDPConn()
client.session = nil
client.hostname = "hostname"
err := client.createNewSession(nil)
@ -116,61 +112,40 @@ var _ = Describe("Client", func() {
Context("handling packets", func() {
It("errors on too large packets", func() {
err := client.handlePacket(bytes.Repeat([]byte{'f'}, int(protocol.MaxPacketSize+1)))
err := client.handlePacket(nil, bytes.Repeat([]byte{'f'}, int(protocol.MaxPacketSize+1)))
Expect(err).To(MatchError(qerr.PacketTooLarge))
})
It("handles packets", func(done Done) {
startUDPConn()
serverConn, err := net.DialUDP("udp", nil, client.conn.LocalAddr().(*net.UDPAddr))
Expect(err).NotTo(HaveOccurred())
var stoppedListening bool
go func() {
defer GinkgoRecover()
_ = client.Listen()
// it should continue listening when receiving valid packets
stoppedListening = true
}()
Expect(sess.packetCount).To(BeZero())
It("handles packets", func() {
ph := PublicHeader{
PacketNumber: 1,
PacketNumberLen: protocol.PacketNumberLen2,
ConnectionID: 0x1337,
}
b := &bytes.Buffer{}
err = ph.Write(b, protocol.Version36, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
_, err = serverConn.Write(b.Bytes())
err := ph.Write(b, protocol.Version36, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
packetConn.dataToRead = b.Bytes()
Expect(sess.packetCount).To(BeZero())
var stoppedListening bool
go func() {
_ = client.Listen()
// it should continue listening when receiving valid packets
stoppedListening = true
}()
Eventually(func() int { return sess.packetCount }).Should(Equal(1))
Expect(sess.closed).To(BeFalse())
Eventually(func() bool { return stoppedListening }).Should(BeFalse())
err = client.Close(nil)
Expect(err).ToNot(HaveOccurred())
close(done)
Consistently(func() bool { return stoppedListening }).Should(BeFalse())
})
It("closes the session when encountering an error while handling a packet", func(done Done) {
startUDPConn()
serverConn, err := net.DialUDP("udp", nil, client.conn.LocalAddr().(*net.UDPAddr))
Expect(err).NotTo(HaveOccurred())
var listenErr error
go func() {
defer GinkgoRecover()
_, err = serverConn.Write(bytes.Repeat([]byte{0xff}, 100))
Expect(err).ToNot(HaveOccurred())
}()
listenErr = client.Listen()
It("closes the session when encountering an error while handling a packet", func() {
packetConn.dataToRead = bytes.Repeat([]byte{0xff}, 100)
listenErr := client.Listen()
Expect(listenErr).To(HaveOccurred())
Eventually(sess.closed).Should(BeTrue())
Expect(sess.closed).To(BeTrue())
Expect(sess.closeReason).To(MatchError(listenErr))
close(done)
})
})
@ -200,19 +175,18 @@ var _ = Describe("Client", func() {
b := &bytes.Buffer{}
err := ph.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
err = client.handlePacket(b.Bytes())
err = client.handlePacket(nil, b.Bytes())
Expect(err).ToNot(HaveOccurred())
Expect(client.versionNegotiated).To(BeTrue())
Expect(versionNegotiateCallbackCalled).To(BeTrue())
})
It("changes the version after receiving a version negotiation packet", func() {
startUDPConn()
newVersion := protocol.Version35
Expect(newVersion).ToNot(Equal(client.version))
Expect(sess.packetCount).To(BeZero())
client.connectionID = 0x1337
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{newVersion}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{newVersion}))
Expect(client.version).To(Equal(newVersion))
Expect(client.versionNegotiated).To(BeTrue())
Expect(versionNegotiateCallbackCalled).To(BeTrue())
@ -229,7 +203,7 @@ var _ = Describe("Client", func() {
})
It("errors if no matching version is found", func() {
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{1}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{1}))
Expect(err).To(MatchError(qerr.InvalidVersion))
})
@ -237,7 +211,7 @@ var _ = Describe("Client", func() {
// if the version was not yet negotiated, handlePacket would return a VersionNegotiationMismatch error, see above test
client.versionNegotiated = true
Expect(sess.packetCount).To(BeZero())
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{1}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{1}))
Expect(err).ToNot(HaveOccurred())
Expect(client.versionNegotiated).To(BeTrue())
Expect(sess.packetCount).To(BeZero())
@ -245,7 +219,7 @@ var _ = Describe("Client", func() {
})
It("errors if the server should have accepted the offered version", func() {
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{client.version}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{client.version}))
Expect(err).To(MatchError(qerr.Error(qerr.InvalidVersionNegotiationPacket, "Server already supports client's version and should have accepted the connection.")))
})
})