Version bump.

[stompngo.git] / codec_test.go

//
// Copyright © 2011-2019 Guy M. Allard
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package stompngo

import (
        "log"
        "os"
        "testing"
        "time"
)

var _ = log.Println

// Test STOMP 1.1 Header Codec - Basic Encode.
func TestCodecEncodeBasic(t *testing.T) {
        for _, _ = range Protocols() {
                for _, ede := range tdList {
                        ev := encode(ede.decoded)
                        if ede.encoded != ev {
                                t.Fatalf("TestCodecEncodeBasic ENCODE ERROR: expected: [%v] got: [%v]",
                                        ede.encoded, ev)
                        }
                }
        }
}

/*
        Test STOMP 1.1 Header Codec - Basic Decode.
*/
func TestCodecDecodeBasic(t *testing.T) {
        for _, _ = range Protocols() {
                for _, ede := range tdList {
                        dv := decode(ede.encoded)
                        if ede.decoded != dv {
                                t.Fatalf("TestCodecDecodeBasic DECODE ERROR: expected: [%v] got: [%v]",
                                        ede.decoded, dv)
                        }
                }
        }
}

func BenchmarkCodecEncode(b *testing.B) {
        for _, _ = range Protocols() {
                for i := 0; i < len(tdList); i++ {
                        for n := 0; n < b.N; n++ {
                                _ = encode(tdList[i].decoded)
                        }
                }
        }
}

func BenchmarkCodecDecode(b *testing.B) {
        for _, _ = range Protocols() {
                for i := 0; i < len(tdList); i++ {
                        for n := 0; n < b.N; n++ {
                                _ = decode(tdList[i].encoded)
                        }
                }
        }
}

/*
        Test STOMP 1.1 Send / Receive - no codec error.
*/
func TestCodecSendRecvCodec(t *testing.T) {
        if os.Getenv("STOMP_ARTEMIS") != "" {
                return
        }
        //
        for _, p := range Protocols() {
                usemap := srcdmap[p]
                //log.Printf("Protocol: %s\n", p)
                //log.Printf("MapLen: %d\n", len(usemap))
                for _, v := range usemap {

                        //
                        // RMQ and STOMP Level 1.0 :
                        // Headers are encoded (as if the STOMP protocol were 1.1
                        // or 1.2).
                        // MAYBEDO: Report issue.  (Is this a bug or a feature?)
                        //
                        if p == SPL_10 && os.Getenv("STOMP_RMQ") != "" {
                                continue
                        }

                        n, _ = openConn(t)
                        ch := login_headers
                        ch = headersProtocol(ch, p)
                        conn, e = Connect(n, ch)
                        if e != nil {
                                t.Fatalf("TestCodecSendRecvCodec CONNECT expected nil, got %v\n", e)
                        }
                        //
                        d := tdest("/queue/gostomp.codec.sendrecv.1.protocol." + p)
                        ms := "msg.codec.sendrecv.1.protocol." + p + " - a message"
                        wh := Headers{HK_DESTINATION, d}

                        //log.Printf("TestData: %+v\n", v)
                        sh := wh.Clone()
                        for i := range v.sk {
                                sh = sh.Add(v.sk[i], v.sv[i])
                        }
                        // Send
                        //log.Printf("Send Headers: %v\n", sh)
                        e = conn.Send(sh, ms)
                        if e != nil {
                                t.Fatalf("TestCodecSendRecvCodec Send failed: %v protocol:%s\n",
                                        e, p)
                        }
                        // Check for ERROR frame
                        time.Sleep(1e9 / 8) // Wait one eigth
                        // Poll for adhoc ERROR from server
                        select {
                        case vx := <-conn.MessageData:
                                t.Fatalf("TestCodecSendRecvCodec Send Error: [%v] protocol:%s\n",
                                        vx, p)
                        default:
                                //
                        }
                        // Subscribe
                        sbh := wh.Add(HK_ID, v.sid)
                        //log.Printf("Subscribe Headers: %v\n", sbh)
                        sc, e = conn.Subscribe(sbh)
                        if e != nil {
                                t.Fatalf("TestCodecSendRecvCodec Subscribe failed: %v protocol:%s\n",
                                        e, p)
                        }
                        if sc == nil {
                                t.Fatalf("TestCodecSendRecvCodec Subscribe sub chan is nil protocol:%s\n",
                                        p)
                        }
                        //
                        checkReceivedMD(t, conn, sc, "codec_test_"+p) // Receive
                        // Check body data
                        b := md.Message.BodyString()
                        if b != ms {
                                t.Fatalf("TestCodecSendRecvCodec Receive expected: [%v] got: [%v] protocol:%s\n",
                                        ms, b, p)
                        }
                        // Unsubscribe
                        //log.Printf("Unsubscribe Headers: %v\n", sbh)
                        e = conn.Unsubscribe(sbh)
                        if e != nil {
                                t.Fatalf("TestCodecSendRecvCodec Unsubscribe failed: %v protocol:%s\n",
                                        e, p)
                        }
                        // Check headers
                        log.Printf("Receive Headers: %v\n", md.Message.Headers)
                        log.Printf("Check map: %v\n", v.rv)
                        for key, value := range v.rv {
                                log.Printf("Want Key: [%v] Value: [%v] \n", key, value)
                                hv, ok = md.Message.Headers.Contains(key)
                                if !ok {
                                        t.Fatalf("TestCodecSendRecvCodec Header key expected: [%v] got: [%v] protocol:%s\n",
                                                key, hv, p)
                                }
                                if value != hv {
                                        t.Fatalf("TestCodecSendRecvCodec Header value expected: [%v] got: [%v] protocol:%s\n",
                                                value, hv, p)
                                }
                        }
                        //
                        checkReceived(t, conn, false)
                        e = conn.Disconnect(empty_headers)
                        checkDisconnectError(t, e)
                        _ = closeConn(t, n)
                }
                //
        }
}