|
|
|
|
@ -2,7 +2,16 @@ package xmpp
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"bytes"
|
|
|
|
|
"encoding/xml"
|
|
|
|
|
"fmt"
|
|
|
|
|
"gosrc.io/xmpp/stanza"
|
|
|
|
|
"strconv"
|
|
|
|
|
"testing"
|
|
|
|
|
"time"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
const (
|
|
|
|
|
streamManagementID = "test-stream_management-id"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func TestClient_Send(t *testing.T) {
|
|
|
|
|
@ -17,3 +26,554 @@ func TestClient_Send(t *testing.T) {
|
|
|
|
|
t.Errorf("Incorrect value sent to buffer: '%s'", buffer.String())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Stream management test.
|
|
|
|
|
// Connection is established, then the server sends supported features and so on.
|
|
|
|
|
// After the bind, client attempts a stream management enablement, and server replies in kind.
|
|
|
|
|
func Test_StreamManagement(t *testing.T) {
|
|
|
|
|
serverDone := make(chan struct{})
|
|
|
|
|
clientDone := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
client, mock := initSrvCliForResumeTests(t, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
enableStreamManagement(t, sc, false, true)
|
|
|
|
|
serverDone <- struct{}{}
|
|
|
|
|
}, testClientStreamManagement, true, true)
|
|
|
|
|
go func() {
|
|
|
|
|
var state SMState
|
|
|
|
|
var err error
|
|
|
|
|
// Client is ok, we now open XMPP session
|
|
|
|
|
if client.Session, err = NewSession(client, state); err != nil {
|
|
|
|
|
t.Fatalf("failed to open XMPP session: %s", err)
|
|
|
|
|
}
|
|
|
|
|
clientDone <- struct{}{}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
waitForEntity(t, clientDone)
|
|
|
|
|
waitForEntity(t, serverDone)
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Absence of stream management test.
|
|
|
|
|
// Connection is established, then the server sends supported features and so on.
|
|
|
|
|
// Client has stream management disabled in its config, and should not ask for it. Server is not set up to reply.
|
|
|
|
|
func Test_NoStreamManagement(t *testing.T) {
|
|
|
|
|
serverDone := make(chan struct{})
|
|
|
|
|
clientDone := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
// Setup Mock server
|
|
|
|
|
client, mock := initSrvCliForResumeTests(t, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesNoStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
serverDone <- struct{}{}
|
|
|
|
|
}, testClientStreamManagement, true, false)
|
|
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
|
var state SMState
|
|
|
|
|
|
|
|
|
|
// Client is ok, we now open XMPP session
|
|
|
|
|
var err error
|
|
|
|
|
if client.Session, err = NewSession(client, state); err != nil {
|
|
|
|
|
t.Fatalf("failed to open XMPP session: %s", err)
|
|
|
|
|
}
|
|
|
|
|
clientDone <- struct{}{}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
waitForEntity(t, clientDone)
|
|
|
|
|
waitForEntity(t, serverDone)
|
|
|
|
|
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Test_StreamManagementNotSupported(t *testing.T) {
|
|
|
|
|
serverDone := make(chan struct{})
|
|
|
|
|
clientDone := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
client, mock := initSrvCliForResumeTests(t, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesNoStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
serverDone <- struct{}{}
|
|
|
|
|
}, testClientStreamManagement, true, true)
|
|
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
|
var state SMState
|
|
|
|
|
var err error
|
|
|
|
|
// Client is ok, we now open XMPP session
|
|
|
|
|
if client.Session, err = NewSession(client, state); err != nil {
|
|
|
|
|
t.Fatalf("failed to open XMPP session: %s", err)
|
|
|
|
|
}
|
|
|
|
|
clientDone <- struct{}{}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
// Wait for client
|
|
|
|
|
waitForEntity(t, clientDone)
|
|
|
|
|
|
|
|
|
|
// Check if client got a positive stream management response from the server
|
|
|
|
|
if client.Session.Features.DoesStreamManagement() {
|
|
|
|
|
t.Fatalf("server does not provide stream management")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Wait for server
|
|
|
|
|
waitForEntity(t, serverDone)
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Test_StreamManagementNoResume(t *testing.T) {
|
|
|
|
|
serverDone := make(chan struct{})
|
|
|
|
|
clientDone := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
client, mock := initSrvCliForResumeTests(t, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
enableStreamManagement(t, sc, false, false)
|
|
|
|
|
serverDone <- struct{}{}
|
|
|
|
|
}, testClientStreamManagement, true, true)
|
|
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
|
var state SMState
|
|
|
|
|
var err error
|
|
|
|
|
// Client is ok, we now open XMPP session
|
|
|
|
|
if client.Session, err = NewSession(client, state); err != nil {
|
|
|
|
|
t.Fatalf("failed to open XMPP session: %s", err)
|
|
|
|
|
}
|
|
|
|
|
clientDone <- struct{}{}
|
|
|
|
|
}()
|
|
|
|
|
waitForEntity(t, clientDone)
|
|
|
|
|
if IsStreamResumable(client) {
|
|
|
|
|
t.Fatalf("server does not support resumption but client says stream is resumable")
|
|
|
|
|
}
|
|
|
|
|
waitForEntity(t, serverDone)
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Test_StreamManagementResume(t *testing.T) {
|
|
|
|
|
// Setup Mock server
|
|
|
|
|
mock := ServerMock{}
|
|
|
|
|
mock.Start(t, testXMPPAddress, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
enableStreamManagement(t, sc, false, true)
|
|
|
|
|
discardPresence(t, sc)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// Test / Check result
|
|
|
|
|
config := Config{
|
|
|
|
|
TransportConfiguration: TransportConfiguration{
|
|
|
|
|
Address: testXMPPAddress,
|
|
|
|
|
},
|
|
|
|
|
Jid: "test@localhost",
|
|
|
|
|
Credential: Password("test"),
|
|
|
|
|
Insecure: true,
|
|
|
|
|
StreamManagementEnable: true,
|
|
|
|
|
streamManagementResume: true} // Enable stream management
|
|
|
|
|
|
|
|
|
|
var client *Client
|
|
|
|
|
router := NewRouter()
|
|
|
|
|
client, err := NewClient(&config, router, clientDefaultErrorHandler)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Errorf("connect create XMPP client: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = client.Connect()
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("could not connect client to mock server: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
statusCorrectChan := make(chan struct{})
|
|
|
|
|
kill := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
transp, ok := client.transport.(*XMPPTransport)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatalf("problem with client transport ")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
transp.conn.Close()
|
|
|
|
|
mock.Stop()
|
|
|
|
|
|
|
|
|
|
// Check if status is correctly updated because of the disconnect
|
|
|
|
|
go checkClientResumeStatus(client, statusCorrectChan, kill)
|
|
|
|
|
select {
|
|
|
|
|
case <-statusCorrectChan:
|
|
|
|
|
// Test passed
|
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
|
kill <- struct{}{}
|
|
|
|
|
t.Fatalf("Client is not in disconnected state while it should be. Timed out")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check if the client can have its connection resumed using its state but also its configuration
|
|
|
|
|
if !IsStreamResumable(client) {
|
|
|
|
|
t.Fatalf("should support resumption")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reboot server. We need to make a new one because (at least for now) the mock server can only have one handler
|
|
|
|
|
// and they should be different between a first connection and a stream resume since exchanged messages
|
|
|
|
|
// are different (See XEP-0198)
|
|
|
|
|
mock2 := ServerMock{}
|
|
|
|
|
mock2.Start(t, testXMPPAddress, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
// Reconnect
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
resumeStream(t, sc)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// Reconnect
|
|
|
|
|
err = client.Resume()
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("could not connect client to mock server: %s", err)
|
|
|
|
|
}
|
|
|
|
|
mock2.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Test_StreamManagementFail(t *testing.T) {
|
|
|
|
|
// Setup Mock server
|
|
|
|
|
mock := ServerMock{}
|
|
|
|
|
mock.Start(t, testXMPPAddress, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
enableStreamManagement(t, sc, true, true)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// Test / Check result
|
|
|
|
|
config := Config{
|
|
|
|
|
TransportConfiguration: TransportConfiguration{
|
|
|
|
|
Address: testXMPPAddress,
|
|
|
|
|
},
|
|
|
|
|
Jid: "test@localhost",
|
|
|
|
|
Credential: Password("test"),
|
|
|
|
|
Insecure: true,
|
|
|
|
|
StreamManagementEnable: true,
|
|
|
|
|
streamManagementResume: true} // Enable stream management
|
|
|
|
|
|
|
|
|
|
var client *Client
|
|
|
|
|
router := NewRouter()
|
|
|
|
|
client, err := NewClient(&config, router, clientDefaultErrorHandler)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Errorf("connect create XMPP client: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var state SMState
|
|
|
|
|
_, err = client.transport.Connect()
|
|
|
|
|
if err != nil {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Client is ok, we now open XMPP session
|
|
|
|
|
if client.Session, err = NewSession(client, state); err == nil {
|
|
|
|
|
t.Fatalf("test is supposed to err")
|
|
|
|
|
}
|
|
|
|
|
if client.Session.SMState.StreamErrorGroup == nil {
|
|
|
|
|
t.Fatalf("error was not stored correctly in session state")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Test_SendStanzaQueueWithSM(t *testing.T) {
|
|
|
|
|
// Setup Mock server
|
|
|
|
|
mock := ServerMock{}
|
|
|
|
|
serverDone := make(chan struct{})
|
|
|
|
|
mock.Start(t, testXMPPAddress, func(t *testing.T, sc *ServerConn) {
|
|
|
|
|
checkClientOpenStream(t, sc)
|
|
|
|
|
|
|
|
|
|
sendStreamFeatures(t, sc) // Send initial features
|
|
|
|
|
readAuth(t, sc.decoder)
|
|
|
|
|
sc.connection.Write([]byte("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>"))
|
|
|
|
|
|
|
|
|
|
checkClientOpenStream(t, sc) // Reset stream
|
|
|
|
|
sendFeaturesStreamManagment(t, sc) // Send post auth features
|
|
|
|
|
bind(t, sc)
|
|
|
|
|
enableStreamManagement(t, sc, false, true)
|
|
|
|
|
|
|
|
|
|
// Ignore the initial presence sent to the server by the client so we can move on to the next packet.
|
|
|
|
|
discardPresence(t, sc)
|
|
|
|
|
|
|
|
|
|
// Used here to silently discard the IQ sent by the client, in order to later trigger a resend
|
|
|
|
|
skipPacket(t, sc)
|
|
|
|
|
// Respond to the client ACK request with a number of processed stanzas of 0. This should trigger a resend
|
|
|
|
|
// of previously ignored stanza to the server, which this handler element will be expecting.
|
|
|
|
|
respondWithAck(t, sc, 0, serverDone)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// Test / Check result
|
|
|
|
|
config := Config{
|
|
|
|
|
TransportConfiguration: TransportConfiguration{
|
|
|
|
|
Address: testXMPPAddress,
|
|
|
|
|
},
|
|
|
|
|
Jid: "test@localhost",
|
|
|
|
|
Credential: Password("test"),
|
|
|
|
|
Insecure: true,
|
|
|
|
|
StreamManagementEnable: true,
|
|
|
|
|
streamManagementResume: true} // Enable stream management
|
|
|
|
|
|
|
|
|
|
var client *Client
|
|
|
|
|
router := NewRouter()
|
|
|
|
|
client, err := NewClient(&config, router, clientDefaultErrorHandler)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Errorf("connect create XMPP client: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = client.Connect()
|
|
|
|
|
|
|
|
|
|
client.SendRaw(`<iq id='ls72g593' type='get'>
|
|
|
|
|
<query xmlns='jabber:iq:roster'/>
|
|
|
|
|
</iq>
|
|
|
|
|
`)
|
|
|
|
|
|
|
|
|
|
// Last stanza was discarded silently by the server. Let's ask an ack for it. This should trigger resend as the server
|
|
|
|
|
// will respond with an acknowledged number of stanzas of 0.
|
|
|
|
|
r := stanza.SMRequest{}
|
|
|
|
|
client.Send(r)
|
|
|
|
|
|
|
|
|
|
select {
|
|
|
|
|
case <-time.After(defaultChannelTimeout):
|
|
|
|
|
t.Fatalf("server failed to complete the test in time")
|
|
|
|
|
case <-serverDone:
|
|
|
|
|
// Test completed successfully
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mock.Stop()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//========================================================================
|
|
|
|
|
// Helper functions for tests
|
|
|
|
|
|
|
|
|
|
func skipPacket(t *testing.T, sc *ServerConn) {
|
|
|
|
|
var p stanza.IQ
|
|
|
|
|
se, err := stanza.NextStart(sc.decoder)
|
|
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("cannot read packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if err := sc.decoder.DecodeElement(&p, &se); err != nil {
|
|
|
|
|
t.Fatalf("cannot decode packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func respondWithAck(t *testing.T, sc *ServerConn, h int, serverDone chan struct{}) {
|
|
|
|
|
|
|
|
|
|
// Mock server reads the ack request
|
|
|
|
|
var p stanza.SMRequest
|
|
|
|
|
se, err := stanza.NextStart(sc.decoder)
|
|
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("cannot read packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if err := sc.decoder.DecodeElement(&p, &se); err != nil {
|
|
|
|
|
t.Fatalf("cannot decode packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Mock server sends the ack response
|
|
|
|
|
a := stanza.SMAnswer{
|
|
|
|
|
H: uint(h),
|
|
|
|
|
}
|
|
|
|
|
data, err := xml.Marshal(a)
|
|
|
|
|
_, err = sc.connection.Write(data)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("failed to send response ack")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Mock server reads the re-sent stanza that was previously discarded intentionally
|
|
|
|
|
var p2 stanza.IQ
|
|
|
|
|
nse, err := stanza.NextStart(sc.decoder)
|
|
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("cannot read packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if err := sc.decoder.DecodeElement(&p2, &nse); err != nil {
|
|
|
|
|
t.Fatalf("cannot decode packet: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
serverDone <- struct{}{}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func sendFeaturesStreamManagment(t *testing.T, sc *ServerConn) {
|
|
|
|
|
// This is a basic server, supporting only 2 features after auth: stream management & session binding
|
|
|
|
|
features := `<stream:features>
|
|
|
|
|
<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>
|
|
|
|
|
<sm xmlns='urn:xmpp:sm:3'/>
|
|
|
|
|
</stream:features>`
|
|
|
|
|
if _, err := fmt.Fprintln(sc.connection, features); err != nil {
|
|
|
|
|
t.Fatalf("cannot send stream feature: %s", err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func sendFeaturesNoStreamManagment(t *testing.T, sc *ServerConn) {
|
|
|
|
|
// This is a basic server, supporting only 2 features after auth: stream management & session binding
|
|
|
|
|
features := `<stream:features>
|
|
|
|
|
<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>
|
|
|
|
|
</stream:features>`
|
|
|
|
|
if _, err := fmt.Fprintln(sc.connection, features); err != nil {
|
|
|
|
|
t.Fatalf("cannot send stream feature: %s", err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// enableStreamManagement is a function for the mock server that can either mock a successful session, or fail depending on
|
|
|
|
|
// the value of the "fail" boolean. True means the session should fail.
|
|
|
|
|
func enableStreamManagement(t *testing.T, sc *ServerConn, fail bool, resume bool) {
|
|
|
|
|
// Decode element into pointer storage
|
|
|
|
|
var ed stanza.SMEnable
|
|
|
|
|
se, err := stanza.NextStart(sc.decoder)
|
|
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("cannot read stream management enable: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if err := sc.decoder.DecodeElement(&ed, &se); err != nil {
|
|
|
|
|
t.Fatalf("cannot decode stream management enable: %s", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if fail {
|
|
|
|
|
f := stanza.SMFailed{
|
|
|
|
|
H: nil,
|
|
|
|
|
StreamErrorGroup: &stanza.UnexpectedRequest{},
|
|
|
|
|
}
|
|
|
|
|
data, err := xml.Marshal(f)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("failed to marshall error response: %s", err)
|
|
|
|
|
}
|
|
|
|
|
sc.connection.Write(data)
|
|
|
|
|
} else {
|
|
|
|
|
e := &stanza.SMEnabled{
|
|
|
|
|
Resume: strconv.FormatBool(resume),
|
|
|
|
|
Id: streamManagementID,
|
|
|
|
|
}
|
|
|
|
|
data, err := xml.Marshal(e)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("failed to marshall error response: %s", err)
|
|
|
|
|
}
|
|
|
|
|
sc.connection.Write(data)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func resumeStream(t *testing.T, sc *ServerConn) {
|
|
|
|
|
h := uint(0)
|
|
|
|
|
response := stanza.SMResumed{
|
|
|
|
|
PrevId: streamManagementID,
|
|
|
|
|
H: &h,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
data, err := xml.Marshal(response)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("failed to marshall stream management enabled response : %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
writtenChan := make(chan struct{})
|
|
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
|
sc.connection.Write(data)
|
|
|
|
|
writtenChan <- struct{}{}
|
|
|
|
|
}()
|
|
|
|
|
select {
|
|
|
|
|
case <-writtenChan:
|
|
|
|
|
// We're done here
|
|
|
|
|
return
|
|
|
|
|
case <-time.After(defaultTimeout):
|
|
|
|
|
t.Fatalf("failed to write enabled nonza to client")
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func checkClientResumeStatus(client *Client, statusCorrectChan chan struct{}, killChan chan struct{}) {
|
|
|
|
|
for {
|
|
|
|
|
if client.CurrentState.getState() == StateDisconnected {
|
|
|
|
|
statusCorrectChan <- struct{}{}
|
|
|
|
|
}
|
|
|
|
|
select {
|
|
|
|
|
case <-killChan:
|
|
|
|
|
return
|
|
|
|
|
case <-time.After(time.Millisecond * 10):
|
|
|
|
|
// Keep checking status value
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func initSrvCliForResumeTests(t *testing.T, serverHandler func(*testing.T, *ServerConn), port int, StreamManagementEnable, StreamManagementResume bool) (*Client, *ServerMock) {
|
|
|
|
|
mock := &ServerMock{}
|
|
|
|
|
testServerAddress := fmt.Sprintf("%s:%d", testClientDomain, port)
|
|
|
|
|
|
|
|
|
|
mock.Start(t, testServerAddress, serverHandler)
|
|
|
|
|
config := Config{
|
|
|
|
|
TransportConfiguration: TransportConfiguration{
|
|
|
|
|
Address: testServerAddress,
|
|
|
|
|
},
|
|
|
|
|
Jid: "test@localhost",
|
|
|
|
|
Credential: Password("test"),
|
|
|
|
|
Insecure: true,
|
|
|
|
|
StreamManagementEnable: StreamManagementEnable,
|
|
|
|
|
streamManagementResume: StreamManagementResume}
|
|
|
|
|
|
|
|
|
|
var client *Client
|
|
|
|
|
var err error
|
|
|
|
|
router := NewRouter()
|
|
|
|
|
if client, err = NewClient(&config, router, clientDefaultErrorHandler); err != nil {
|
|
|
|
|
t.Fatalf("connect create XMPP client: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if _, err = client.transport.Connect(); err != nil {
|
|
|
|
|
t.Fatalf("XMPP connection failed: %s", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return client, mock
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func waitForEntity(t *testing.T, entityDone chan struct{}) {
|
|
|
|
|
select {
|
|
|
|
|
case <-entityDone:
|
|
|
|
|
case <-time.After(defaultTimeout):
|
|
|
|
|
t.Fatalf("test timed out")
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
rcorniere
4 years ago