func TestMain(m *testing.M) {
ts = smpptest.NewUnstartedServer()
ts.Handler = pduHandler
ts.Start()
defer ts.Close()
os.Exit(m.Run())
}
func TestQuerySM(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
r := pdu.NewQuerySMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, p.Fields()[pdufield.MessageID])
r.Fields().Set(pdufield.MessageState, 2)
c.Write(r)
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
}
defer tx.Close()
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
qr, err := tx.QuerySM("root", "13")
if err != nil {
t.Fatal(err)
}
if qr.MsgID != "13" {
t.Fatalf("unexpected msgid: want 13, have %s", qr.MsgID)
}
if qr.MsgState != "DELIVERED" {
t.Fatalf("unexpected state: want DELIVERED, have %q", qr.MsgState)
}
}
func TestShortMessageWindowSize(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
time.Sleep(200 * time.Millisecond)
r := pdu.NewSubmitSMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
c.Write(r)
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
WindowSize: 2,
RespTimeout: time.Second,
}
defer tx.Close()
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
msgc := make(chan *ShortMessage, 3)
defer close(msgc)
errc := make(chan error, 3)
for i := 0; i < 3; i++ {
go func(msgc chan *ShortMessage, errc chan error) {
m := <-msgc
if m == nil {
return
}
_, err := tx.Submit(m)
errc <- err
}(msgc, errc)
msgc <- &ShortMessage{
Src: "root",
Dst: "foobar",
Text: pdutext.Raw("Lorem ipsum"),
Validity: 10 * time.Minute,
Register: NoDeliveryReceipt,
}
}
nerr := 0
for i := 0; i < 3; i++ {
if <-errc == ErrMaxWindowSize {
nerr++
}
}
if nerr != 1 {
t.Fatalf("unexpected # of errors. want 1, have %d", nerr)
}
}
func TestLongMessage(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
switch p.Header().ID {
case pdu.SubmitSMID:
r := pdu.NewSubmitSMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
c.Write(r)
default:
smpptest.EchoHandler(c, p)
}
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
}
defer tx.Close()
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
sm, err := tx.SubmitLongMsg(&ShortMessage{
Src: "root",
Dst: "foobar",
Text: pdutext.Raw("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam consequat nisl enim, vel finibus neque aliquet sit amet. Interdum et malesuada fames ac ante ipsum primis in faucibus."),
Validity: 10 * time.Minute,
Register: NoDeliveryReceipt,
})
if err != nil {
t.Fatal(err)
}
msgid := sm.RespID()
if msgid == "" {
t.Fatalf("pdu does not contain msgid: %#v", sm.Resp())
}
if msgid != "foobar" {
t.Fatalf("unexpected msgid: want foobar, have %q", msgid)
}
}
func TestShortMessage(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
switch p.Header().ID {
case pdu.SubmitSMID:
r := pdu.NewSubmitSMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
c.Write(r)
default:
smpptest.EchoHandler(c, p)
}
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
}
defer tx.Close()
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
sm, err := tx.Submit(&ShortMessage{
Src: "root",
Dst: "foobar",
Text: pdutext.Raw("Lorem ipsum"),
Register: NoDeliveryReceipt,
})
if err != nil {
t.Fatal(err)
}
msgid := sm.RespID()
if msgid == "" {
t.Fatalf("pdu does not contain msgid: %#v", sm.Resp())
}
if msgid != "foobar" {
t.Fatalf("unexpected msgid: want foobar, have %q", msgid)
}
}
func TestNotConnected(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
switch p.Header().ID {
case pdu.SubmitSMID:
r := pdu.NewSubmitSMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
c.Write(r)
default:
smpptest.EchoHandler(c, p)
}
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
}
// Open connection and then close it
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
tx.Close()
_, err := tx.Submit(&ShortMessage{
Src: "root",
Dst: "foobar",
Text: pdutext.Raw("Lorem ipsum"),
Validity: 10 * time.Minute,
Register: NoDeliveryReceipt,
})
if err != ErrNotConnected {
t.Fatalf("Error should be not connect, got %s", err.Error())
}
}
func TestSubmitMulti(t *testing.T) {
//construct a byte array with the UnsuccessSme
var bArray []byte
bArray = append(bArray, byte(0x00)) // TON
bArray = append(bArray, byte(0x00)) // NPI
bArray = append(bArray, []byte("123")...) // Address
bArray = append(bArray, byte(0x00)) // Error
bArray = append(bArray, byte(0x00)) // Error
bArray = append(bArray, byte(0x00)) // Error
bArray = append(bArray, byte(0x11)) // Error
bArray = append(bArray, byte(0x00)) // null terminator
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
switch p.Header().ID {
case pdu.SubmitMultiID:
r := pdu.NewSubmitMultiResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
r.Fields().Set(pdufield.NoUnsuccess, uint8(1))
r.Fields().Set(pdufield.UnsuccessSme, bArray)
c.Write(r)
default:
smpptest.EchoHandler(c, p)
}
}
s.Start()
defer s.Close()
tx := &Transmitter{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
}
defer tx.Close()
conn := <-tx.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
sm, err := tx.Submit(&ShortMessage{
Src: "root",
DstList: []string{"123", "2233", "32322", "4234234"},
DLs: []string{"DistributionList1"},
Text: pdutext.Raw("Lorem ipsum"),
Validity: 10 * time.Minute,
Register: NoDeliveryReceipt,
})
if err != nil {
t.Fatal(err)
}
msgid := sm.RespID()
if msgid == "" {
t.Fatalf("pdu does not contain msgid: %#v", sm.Resp())
}
if msgid != "foobar" {
t.Fatalf("unexpected msgid: want foobar, have %q", msgid)
}
noUncess, _ := sm.NumbUnsuccess()
if noUncess != 1 {
t.Fatalf("unexpected number of unsuccess %d", noUncess)
}
uncessSmes, _ := sm.UnsuccessSmes()
if len(uncessSmes) != 1 {
t.Fatalf("unsucess sme list should have a size of 1, has %d", len(uncessSmes))
}
}
func TestTransceiver(t *testing.T) {
s := smpptest.NewUnstartedServer()
s.Handler = func(c smpptest.Conn, p pdu.Body) {
switch p.Header().ID {
case pdu.SubmitSMID:
r := pdu.NewSubmitSMResp()
r.Header().Seq = p.Header().Seq
r.Fields().Set(pdufield.MessageID, "foobar")
c.Write(r)
pf := p.Fields()
rd := pf[pdufield.RegisteredDelivery]
if rd.Bytes()[0] == 0 {
return
}
r = pdu.NewDeliverSM()
f := r.Fields()
f.Set(pdufield.SourceAddr, pf[pdufield.SourceAddr])
f.Set(pdufield.DestinationAddr, pf[pdufield.DestinationAddr])
f.Set(pdufield.ShortMessage, pf[pdufield.ShortMessage])
c.Write(r)
default:
smpptest.EchoHandler(c, p)
}
}
s.Start()
defer s.Close()
ack := make(chan error)
receiver := func(p pdu.Body) {
defer close(ack)
if p.Header().ID != pdu.DeliverSMID {
ack <- fmt.Errorf("unexpected PDU: %s", p.Header().ID)
}
}
tc := &Transceiver{
Addr: s.Addr(),
User: smpptest.DefaultUser,
Passwd: smpptest.DefaultPasswd,
Handler: receiver,
}
defer tc.Close()
conn := <-tc.Bind()
switch conn.Status() {
case Connected:
default:
t.Fatal(conn.Error())
}
sm, err := tc.Submit(&ShortMessage{
Src: "root",
Dst: "foobar",
Text: pdutext.Raw("Lorem ipsum"),
Register: FinalDeliveryReceipt,
})
if err != nil {
t.Fatal(err)
}
msgid := sm.RespID()
if msgid == "" {
t.Fatalf("pdu does not contain msgid: %#v", sm.Resp())
}
if msgid != "foobar" {
t.Fatalf("unexpected msgid: want foobar, have %q", msgid)
}
select {
case err := <-ack:
if err != nil {
t.Fatal(err)
}
case <-time.After(time.Second):
t.Fatal("timeout waiting for ack")
}
}