misc_test.go

   1 //
   2 // Copyright © 2012-2019 Guy M. Allard
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 package stompngo
  18
  19 import (
  20         "testing"
  21 )
  22
  23 /*
  24         Test A zero Byte Message, a corner case.
  25 */
  26 func TestMiscBytes0(t *testing.T) {
  27         for _, sp := range Protocols() {
  28                 //tlg.Printf("TestMiscBytes0 protocol:%s\n", sp)
  29                 // Write phase
  30                 //tlg.Printf("TestMiscBytes0 WRITEPHASE\n")
  31                 n, _ = openConn(t)
  32                 ch := login_headers
  33                 ch = headersProtocol(ch, sp)
  34                 conn, e = Connect(n, ch)
  35                 if e != nil {
  36                         t.Fatalf("TestMiscBytes0 CONNECT expected nil, got %v\n", e)
  37                 }
  38                 //
  39                 ms := "" // No data
  40                 d := tdest("/queue/misc.zero.byte.msg." + sp)
  41                 sh := Headers{HK_DESTINATION, d}
  42                 e = conn.Send(sh, ms)
  43                 if e != nil {
  44                         t.Fatalf("TestMiscBytes0 Expected nil error, got [%v]\n", e)
  45                 }
  46                 //
  47                 checkReceived(t, conn, false)
  48                 e = conn.Disconnect(empty_headers)
  49                 checkDisconnectError(t, e)
  50                 _ = closeConn(t, n)
  51
  52                 // Read phase
  53                 //tlg.Printf("TestMiscBytes0 READPHASE\n")
  54                 n, _ = openConn(t)
  55                 ch = login_headers
  56                 ch = headersProtocol(ch, sp)
  57                 conn, _ = Connect(n, ch)
  58                 //
  59                 sbh := sh.Add(HK_ID, d)
  60                 sc, e = conn.Subscribe(sbh)
  61                 if e != nil {
  62                         t.Fatalf("TestMiscBytes0 Expected no subscribe error, got [%v]\n", e)
  63                 }
  64                 if sc == nil {
  65                         t.Fatalf("TestMiscBytes0 Expected subscribe channel, got [nil]\n")
  66                 }
  67
  68                 // Read MessageData
  69                 var md MessageData
  70                 select {
  71                 case md = <-sc:
  72                 case md = <-conn.MessageData:
  73                         t.Fatalf("TestMiscBytes0 read channel error:  expected [nil], got: [%v]\n",
  74                                 md.Message.Command)
  75                 }
  76
  77                 if md.Error != nil {
  78                         t.Fatalf("TestMiscBytes0 Expected no message data error, got [%v]\n",
  79                                 md.Error)
  80                 }
  81
  82                 // The real tests here
  83                 if len(md.Message.Body) != 0 {
  84                         t.Fatalf("TestMiscBytes0 Expected body length 0, got [%v]\n",
  85                                 len(md.Message.Body))
  86                 }
  87                 if string(md.Message.Body) != ms {
  88                         t.Fatalf("TestMiscBytes0 Expected [%v], got [%v]\n",
  89                                 ms, string(md.Message.Body))
  90                 }
  91                 //
  92                 //tlg.Printf("TestMiscBytes0 CLEANUP\n")
  93                 checkReceived(t, conn, false)
  94                 e = conn.Disconnect(empty_headers)
  95                 checkDisconnectError(t, e)
  96                 _ = closeConn(t, n)
  97         }
  98 }
  99
 100 /*
 101         Test A One Byte Message, a corner case.
 102 */
 103 func TestMiscBytes1(t *testing.T) {
 104         for _, sp := range Protocols() {
 105                 //tlg.Printf("TestMiscBytes0 protocol:%s\n", sp)
 106                 // Write phase
 107                 //tlg.Printf("TestMiscBytes0 WRITEPHASE\n")
 108                 n, _ = openConn(t)
 109                 ch := login_headers
 110                 ch = headersProtocol(ch, sp)
 111                 conn, e = Connect(n, ch)
 112                 if e != nil {
 113                         t.Fatalf("TestMiscBytes1 CONNECT expected nil, got %v\n", e)
 114                 }
 115                 //
 116                 ms := "Z" // One Byte
 117                 d := tdest("/queue/misc.zero.byte.msg." + sp)
 118                 sh := Headers{HK_DESTINATION, d}
 119                 e = conn.Send(sh, ms)
 120                 if e != nil {
 121                         t.Fatalf("TestMiscBytes1 Expected nil error, got [%v]\n", e)
 122                 }
 123                 //
 124                 checkReceived(t, conn, false)
 125                 e = conn.Disconnect(empty_headers)
 126                 checkDisconnectError(t, e)
 127                 _ = closeConn(t, n)
 128
 129                 // Read phase
 130                 //tlg.Printf("TestMiscBytes1 READPHASE\n")
 131                 n, _ = openConn(t)
 132                 ch = login_headers
 133                 ch = headersProtocol(ch, sp)
 134                 conn, _ = Connect(n, ch)
 135                 //
 136                 sbh := sh.Add(HK_ID, d)
 137                 sc, e = conn.Subscribe(sbh)
 138                 if e != nil {
 139                         t.Fatalf("TestMiscBytes1 Expected no subscribe error, got [%v]\n", e)
 140                 }
 141                 if sc == nil {
 142                         t.Fatalf("TestMiscBytes1 Expected subscribe channel, got [nil]\n")
 143                 }
 144
 145                 // Read MessageData
 146                 var md MessageData
 147                 select {
 148                 case md = <-sc:
 149                 case md = <-conn.MessageData:
 150                         t.Fatalf("TestMiscBytes1 read channel error:  expected [nil], got: [%v]\n",
 151                                 md.Message.Command)
 152                 }
 153
 154                 if md.Error != nil {
 155                         t.Fatalf("TestMiscBytes1 Expected no message data error, got [%v]\n",
 156                                 md.Error)
 157                 }
 158
 159                 // The real tests here
 160                 if len(md.Message.Body) != 1 {
 161                         t.Fatalf("TestMiscBytes1 Expected body length 1, got [%v]\n",
 162                                 len(md.Message.Body))
 163                 }
 164                 if string(md.Message.Body) != ms {
 165                         t.Fatalf("TestMiscBytes1 Expected [%v], got [%v]\n",
 166                                 ms, string(md.Message.Body))
 167                 }
 168                 //
 169                 //tlg.Printf("TestMiscBytes1 CLEANUP\n")
 170                 checkReceived(t, conn, false)
 171                 e = conn.Disconnect(empty_headers)
 172                 checkDisconnectError(t, e)
 173                 _ = closeConn(t, n)
 174         }
 175 }
 176
 177 /*
 178         Test nil Headers.
 179 */
 180 func TestMiscNilHeaders(t *testing.T) {
 181         for _, _ = range Protocols() {
 182                 n, _ = openConn(t)
 183                 //
 184                 _, e = Connect(n, nil)
 185                 if e == nil {
 186                         t.Fatalf("TestMiscNilHeaders Expected [%v], got [nil]\n",
 187                                 EHDRNIL)
 188                 }
 189                 if e != EHDRNIL {
 190                         t.Fatalf("TestMiscNilHeaders Expected [%v], got [%v]\n",
 191                                 EHDRNIL, e)
 192                 }
 193                 //
 194                 ch := check11(TEST_HEADERS)
 195                 conn, _ = Connect(n, ch)
 196                 //
 197                 e = nil // reset
 198                 e = conn.Abort(nil)
 199                 if e == nil {
 200                         t.Fatalf("TestMiscNilHeaders Abort Expected [%v], got [nil]\n",
 201                                 EHDRNIL)
 202                 }
 203                 //
 204                 e = nil // reset
 205                 e = conn.Ack(nil)
 206                 if e == nil {
 207                         t.Fatalf("TestMiscNilHeaders Ack Expected [%v], got [nil]\n",
 208                                 EHDRNIL)
 209                 }
 210                 //
 211                 e = nil // reset
 212                 e = conn.Begin(nil)
 213                 if e == nil {
 214                         t.Fatalf("TestMiscNilHeaders Begin Expected [%v], got [nil]\n",
 215                                 EHDRNIL)
 216                 }
 217                 //
 218                 e = nil // reset
 219                 e = conn.Commit(nil)
 220                 if e == nil {
 221                         t.Fatalf("TestMiscNilHeaders Commit Expected [%v], got [nil]\n",
 222                                 EHDRNIL)
 223                 }
 224                 //
 225                 e = nil // reset
 226                 e = conn.Disconnect(nil)
 227                 if e == nil {
 228                         t.Fatalf("TestMiscNilHeaders Disconnect Expected [%v], got [nil]\n",
 229                                 EHDRNIL)
 230                 }
 231                 //
 232                 if conn.Protocol() > SPL_10 {
 233                         e = nil // reset
 234                         e = conn.Disconnect(nil)
 235                         if e == nil {
 236                                 t.Fatalf("TestMiscNilHeaders Nack Expected [%v], got [nil]\n",
 237                                         EHDRNIL)
 238                         }
 239                 }
 240                 //
 241                 e = nil // reset
 242                 e = conn.Send(nil, "")
 243                 if e == nil {
 244                         t.Fatalf("TestMiscNilHeaders Send Expected [%v], got [nil]\n",
 245                                 EHDRNIL)
 246                 }
 247                 //
 248         }
 249 }
 250
 251 /*
 252 Test max function.
 253 */
 254 func TestMiscMax(t *testing.T) {
 255         for _, _ = range Protocols() {
 256                 var l int64 = 1 // low
 257                 var h int64 = 2 // high
 258                 mr := max(l, h)
 259                 if mr != 2 {
 260                         t.Fatalf("TestMiscMax Expected [%v], got [%v]\n", h, mr)
 261                 }
 262                 mr = max(h, l)
 263                 if mr != 2 {
 264                         t.Fatalf("TestMiscMax Expected [%v], got [%v]\n", h, mr)
 265                 }
 266         }
 267 }
 268
 269 /*
 270 Test hasValue function.
 271 */
 272 func TestMiscHasValue(t *testing.T) {
 273         for _, _ = range Protocols() {
 274                 sa := []string{"a", "b"}
 275                 if !hasValue(sa, "a") {
 276                         t.Fatalf("TestMiscHasValue Expected [true], got [false] for [%v]\n", "a")
 277                 }
 278                 if hasValue(sa, "z") {
 279                         t.Fatalf("TestMiscHasValue Expected [false], got [true] for [%v]\n", "z")
 280                 }
 281         }
 282 }
 283
 284 /*
 285 Test Uuid function.
 286 */
 287 func TestMiscUuid(t *testing.T) {
 288         for _, _ = range Protocols() {
 289                 id := Uuid()
 290                 if id == "" {
 291                         t.Fatalf("TestMiscUuid Expected a UUID, got empty string\n")
 292                 }
 293                 if len(id) != 36 {
 294                         t.Fatalf("TestMiscUuid Expected a 36 character UUID, got length [%v]\n",
 295                                 len(id))
 296                 }
 297         }
 298 }
 299
 300 /*
 301         Test Bad Headers
 302 */
 303 func TestMiscBadHeaders(t *testing.T) {
 304         for _, sp = range Protocols() {
 305                 //
 306                 n, _ = openConn(t)
 307                 neh := Headers{"a", "b", "c"} // not even number header count
 308                 conn, e = Connect(n, neh)
 309
 310                 // Connection should be nil (i.e. no connection)
 311                 if e == nil {
 312                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [nil]\n", EHDRLEN)
 313                 }
 314                 if e != EHDRLEN {
 315                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [%v]\n", EHDRLEN, e)
 316                 }
 317                 //
 318                 bvh := Headers{HK_HOST, "localhost", HK_ACCEPT_VERSION, "3.14159"}
 319                 conn, e = Connect(n, bvh)
 320                 if e == nil {
 321                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [nil]\n", EBADVERCLI)
 322                 }
 323                 if e != EBADVERCLI {
 324                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [%v]\n", EBADVERCLI, e)
 325                 }
 326
 327                 //
 328                 ch := login_headers
 329                 ch = headersProtocol(ch, sp)
 330                 //log.Printf("TestMiscBadHeaders Protocol %s, CONNECT Headers: %v\n", sp, ch)
 331                 conn, e = Connect(n, ch)
 332                 if e != nil {
 333                         t.Fatalf("TestMiscBadHeaders CONNECT 2 expected nil, got %v connectresponse: %v\n",
 334                                 e, conn.ConnectResponse)
 335                 }
 336
 337                 // Connection should not be nil (i.e. good connection)
 338                 _, e = conn.Subscribe(neh)
 339                 if e == nil {
 340                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [nil]\n", EHDRLEN)
 341                 }
 342                 if e != EHDRLEN {
 343                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [%v]\n", EHDRLEN, e)
 344                 }
 345                 //
 346                 e = conn.Unsubscribe(neh)
 347                 if e == nil {
 348                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [nil]\n", EHDRLEN)
 349                 }
 350                 if e != EHDRLEN {
 351                         t.Fatalf("TestMiscBadHeaders Expected [%v], got [%v]\n", EHDRLEN, e)
 352                 }
 353                 //
 354                 if conn != nil && conn.Connected() {
 355                         e = conn.Disconnect(empty_headers)
 356                         checkDisconnectError(t, e)
 357                 }
 358                 _ = closeConn(t, n)
 359         }
 360 }