wamp_client 0.0.9 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +28 -26
  3. data/lib/{wamp_client.rb → wamp/client.rb} +8 -8
  4. data/lib/{wamp_client → wamp/client}/auth.rb +13 -11
  5. data/lib/wamp/client/check.rb +86 -0
  6. data/lib/wamp/client/connection.rb +249 -0
  7. data/lib/{wamp_client → wamp/client}/defer.rb +29 -27
  8. data/lib/wamp/client/message.rb +1322 -0
  9. data/lib/{wamp_client → wamp/client}/serializer.rb +26 -24
  10. data/lib/wamp/client/session.rb +1001 -0
  11. data/lib/wamp/client/transport/base.rb +152 -0
  12. data/lib/{wamp_client → wamp/client}/transport/event_machine_base.rb +19 -17
  13. data/lib/wamp/client/transport/faye_web_socket.rb +85 -0
  14. data/lib/wamp/client/transport/web_socket_event_machine.rb +88 -0
  15. data/lib/{wamp_client → wamp/client}/version.rb +5 -3
  16. data/scripts/gen_message.rb +54 -53
  17. data/spec/spec_helper.rb +3 -3
  18. data/spec/{auth_spec.rb → wamp/client/auth_spec.rb} +2 -2
  19. data/spec/{check_spec.rb → wamp/client/check_spec.rb} +2 -2
  20. data/spec/{connection_spec.rb → wamp/client/connection_spec.rb} +7 -7
  21. data/spec/{message_spec.rb → wamp/client/message_spec.rb} +298 -298
  22. data/spec/{session_spec.rb → wamp/client/session_spec.rb} +134 -134
  23. data/spec/{transport_spec.rb → wamp/client/transport_spec.rb} +4 -4
  24. data/wamp_client.gemspec +2 -2
  25. metadata +50 -50
  26. data/lib/wamp_client/check.rb +0 -84
  27. data/lib/wamp_client/connection.rb +0 -247
  28. data/lib/wamp_client/message.rb +0 -1348
  29. data/lib/wamp_client/session.rb +0 -1000
  30. data/lib/wamp_client/transport/base.rb +0 -151
  31. data/lib/wamp_client/transport/faye_web_socket.rb +0 -83
  32. data/lib/wamp_client/transport/web_socket_event_machine.rb +0 -86
data/spec/spec_helper.rb CHANGED
@@ -1,19 +1,19 @@
1
1
  require 'simplecov'
2
2
  SimpleCov.start
3
3
 
4
- require_relative '../lib/wamp_client'
4
+ require_relative '../lib/wamp/client'
5
5
 
6
6
  if ENV['CODECOV_TOKEN']
7
7
  require 'codecov'
8
8
  SimpleCov.formatter = SimpleCov::Formatter::Codecov
9
9
  end
10
10
 
11
- require 'wamp_client'
11
+ require 'wamp/client'
12
12
  require "rspec/em"
13
13
 
14
14
  module SpecHelper
15
15
 
16
- class TestTransport < WampClient::Transport::EventMachineBase
16
+ class TestTransport < Wamp::Client::Transport::EventMachineBase
17
17
  @@event_machine_on = false
18
18
  attr_accessor :messages
19
19
 
@@ -1,6 +1,6 @@
1
1
  require 'spec_helper'
2
2
 
3
- describe WampClient::Auth do
3
+ describe Wamp::Client::Auth do
4
4
 
5
5
  describe 'cra' do
6
6
 
@@ -8,7 +8,7 @@ describe WampClient::Auth do
8
8
 
9
9
  challenge = "{ \"nonce\": \"LHRTC9zeOIrt_9U3\", \"authprovider\": \"userdb\", \"authid\": \"peter\", \"timestamp\": \"2014-06-22T16:36:25.448Z\", \"authrole\": \"user\", \"authmethod\": \"wampcra\", \"session\": 3251278072152162}"
10
10
  secret = 'secret'
11
- signature = WampClient::Auth::Cra.sign(secret, challenge)
11
+ signature = Wamp::Client::Auth::Cra.sign(secret, challenge)
12
12
  expect(signature).to eq('Pji30JC9tb/T9tbEwxw5i0RyRa5UVBxuoIVTgT7hnkE=')
13
13
 
14
14
  end
@@ -1,9 +1,9 @@
1
1
  require 'spec_helper'
2
2
 
3
- describe WampClient::Check do
3
+ describe Wamp::Client::Check do
4
4
 
5
5
  class DummyClass
6
- include WampClient::Check
6
+ include Wamp::Client::Check
7
7
  end
8
8
 
9
9
  describe '#check_equal' do
@@ -1,6 +1,6 @@
1
1
  require 'spec_helper'
2
2
 
3
- describe WampClient::Connection do
3
+ describe Wamp::Client::Connection do
4
4
  include RSpec::EM::FakeClock
5
5
 
6
6
  before { clock.stub }
@@ -26,13 +26,13 @@ describe WampClient::Connection do
26
26
 
27
27
  def open_session_from_server
28
28
  # Send welcome form server
29
- welcome = WampClient::Message::Welcome.new(1234, {})
29
+ welcome = Wamp::Client::Message::Welcome.new(1234, {})
30
30
  transport.receive_message(welcome.payload)
31
31
  end
32
32
 
33
33
  def close_session_from_server
34
34
  # Send goodbye from server
35
- goodbye = WampClient::Message::Goodbye.new({}, 'felt.like.it')
35
+ goodbye = Wamp::Client::Message::Goodbye.new({}, 'felt.like.it')
36
36
  transport.receive_message(goodbye.payload)
37
37
  end
38
38
 
@@ -47,12 +47,12 @@ describe WampClient::Connection do
47
47
  describe 'transport' do
48
48
  it 'selects the default transport' do
49
49
  connection = described_class.new({})
50
- expect(connection.transport_class).to be(WampClient::Transport::WebSocketEventMachine)
50
+ expect(connection.transport_class).to be(Wamp::Client::Transport::WebSocketEventMachine)
51
51
  end
52
52
 
53
53
  it 'overrides the default transport' do
54
- connection = described_class.new({ transport: WampClient::Transport::FayeWebSocket })
55
- expect(connection.transport_class).to be(WampClient::Transport::FayeWebSocket)
54
+ connection = described_class.new({ transport: Wamp::Client::Transport::FayeWebSocket })
55
+ expect(connection.transport_class).to be(Wamp::Client::Transport::FayeWebSocket)
56
56
  end
57
57
  end
58
58
 
@@ -67,7 +67,7 @@ describe WampClient::Connection do
67
67
  expect(transport).not_to be_nil
68
68
  expect(session).not_to be_nil
69
69
  expect(transport.messages.count).to eq(1)
70
- expect(transport.messages[0][0]).to eq(WampClient::Message::Types::HELLO)
70
+ expect(transport.messages[0][0]).to eq(Wamp::Client::Message::Types::HELLO)
71
71
 
72
72
  expect(called).to eq(true)
73
73
  end
@@ -2,40 +2,40 @@ require 'spec_helper'
2
2
 
3
3
  # !!!!THIS FILE IS AUTOGENERATED. DO NOT HAND EDIT!!!!
4
4
 
5
- describe WampClient::Message do
5
+ describe Wamp::Client::Message do
6
6
 
7
- describe WampClient::Message::Hello do
7
+ describe Wamp::Client::Message::Hello do
8
8
 
9
9
  it 'creates the message object' do
10
10
  params = ['string',{ test: 1 }]
11
- object = WampClient::Message::Hello.new(*params)
11
+ object = Wamp::Client::Message::Hello.new(*params)
12
12
 
13
13
  expect(object.realm).to eq('string')
14
14
  expect(object.details).to eq({ test: 1 })
15
- expect(object.is_a?(WampClient::Message::Hello)).to eq(true)
15
+ expect(object.is_a?(Wamp::Client::Message::Hello)).to eq(true)
16
16
  end
17
17
 
18
18
  it 'parses the message and creates an object' do
19
19
  params = [1,'string',{ test: 1 }]
20
- object = WampClient::Message::Hello.parse(params)
20
+ object = Wamp::Client::Message::Hello.parse(params)
21
21
 
22
22
  expect(object.realm).to eq('string')
23
23
  expect(object.details).to eq({ test: 1 })
24
- expect(object.is_a?(WampClient::Message::Hello)).to eq(true)
24
+ expect(object.is_a?(Wamp::Client::Message::Hello)).to eq(true)
25
25
  end
26
26
 
27
27
  it 'globally parses the message and creates an object' do
28
28
  params = [1,'string',{ test: 1 }]
29
- object = WampClient::Message::Base.parse(params)
29
+ object = Wamp::Client::Message::Base.parse(params)
30
30
 
31
31
  expect(object.realm).to eq('string')
32
32
  expect(object.details).to eq({ test: 1 })
33
- expect(object.is_a?(WampClient::Message::Hello)).to eq(true)
33
+ expect(object.is_a?(Wamp::Client::Message::Hello)).to eq(true)
34
34
  end
35
35
 
36
36
  it 'generates the payload' do
37
37
  params = ['string',{ test: 1 }]
38
- object = WampClient::Message::Hello.new(*params)
38
+ object = Wamp::Client::Message::Hello.new(*params)
39
39
  payload = object.payload
40
40
 
41
41
  expect(payload.count).to eq(3)
@@ -46,38 +46,38 @@ describe WampClient::Message do
46
46
 
47
47
  end
48
48
 
49
- describe WampClient::Message::Welcome do
49
+ describe Wamp::Client::Message::Welcome do
50
50
 
51
51
  it 'creates the message object' do
52
52
  params = [123,{ test: 1 }]
53
- object = WampClient::Message::Welcome.new(*params)
53
+ object = Wamp::Client::Message::Welcome.new(*params)
54
54
 
55
55
  expect(object.session).to eq(123)
56
56
  expect(object.details).to eq({ test: 1 })
57
- expect(object.is_a?(WampClient::Message::Welcome)).to eq(true)
57
+ expect(object.is_a?(Wamp::Client::Message::Welcome)).to eq(true)
58
58
  end
59
59
 
60
60
  it 'parses the message and creates an object' do
61
61
  params = [2,123,{ test: 1 }]
62
- object = WampClient::Message::Welcome.parse(params)
62
+ object = Wamp::Client::Message::Welcome.parse(params)
63
63
 
64
64
  expect(object.session).to eq(123)
65
65
  expect(object.details).to eq({ test: 1 })
66
- expect(object.is_a?(WampClient::Message::Welcome)).to eq(true)
66
+ expect(object.is_a?(Wamp::Client::Message::Welcome)).to eq(true)
67
67
  end
68
68
 
69
69
  it 'globally parses the message and creates an object' do
70
70
  params = [2,123,{ test: 1 }]
71
- object = WampClient::Message::Base.parse(params)
71
+ object = Wamp::Client::Message::Base.parse(params)
72
72
 
73
73
  expect(object.session).to eq(123)
74
74
  expect(object.details).to eq({ test: 1 })
75
- expect(object.is_a?(WampClient::Message::Welcome)).to eq(true)
75
+ expect(object.is_a?(Wamp::Client::Message::Welcome)).to eq(true)
76
76
  end
77
77
 
78
78
  it 'generates the payload' do
79
79
  params = [123,{ test: 1 }]
80
- object = WampClient::Message::Welcome.new(*params)
80
+ object = Wamp::Client::Message::Welcome.new(*params)
81
81
  payload = object.payload
82
82
 
83
83
  expect(payload.count).to eq(3)
@@ -88,38 +88,38 @@ describe WampClient::Message do
88
88
 
89
89
  end
90
90
 
91
- describe WampClient::Message::Abort do
91
+ describe Wamp::Client::Message::Abort do
92
92
 
93
93
  it 'creates the message object' do
94
94
  params = [{ test: 1 },'string']
95
- object = WampClient::Message::Abort.new(*params)
95
+ object = Wamp::Client::Message::Abort.new(*params)
96
96
 
97
97
  expect(object.details).to eq({ test: 1 })
98
98
  expect(object.reason).to eq('string')
99
- expect(object.is_a?(WampClient::Message::Abort)).to eq(true)
99
+ expect(object.is_a?(Wamp::Client::Message::Abort)).to eq(true)
100
100
  end
101
101
 
102
102
  it 'parses the message and creates an object' do
103
103
  params = [3,{ test: 1 },'string']
104
- object = WampClient::Message::Abort.parse(params)
104
+ object = Wamp::Client::Message::Abort.parse(params)
105
105
 
106
106
  expect(object.details).to eq({ test: 1 })
107
107
  expect(object.reason).to eq('string')
108
- expect(object.is_a?(WampClient::Message::Abort)).to eq(true)
108
+ expect(object.is_a?(Wamp::Client::Message::Abort)).to eq(true)
109
109
  end
110
110
 
111
111
  it 'globally parses the message and creates an object' do
112
112
  params = [3,{ test: 1 },'string']
113
- object = WampClient::Message::Base.parse(params)
113
+ object = Wamp::Client::Message::Base.parse(params)
114
114
 
115
115
  expect(object.details).to eq({ test: 1 })
116
116
  expect(object.reason).to eq('string')
117
- expect(object.is_a?(WampClient::Message::Abort)).to eq(true)
117
+ expect(object.is_a?(Wamp::Client::Message::Abort)).to eq(true)
118
118
  end
119
119
 
120
120
  it 'generates the payload' do
121
121
  params = [{ test: 1 },'string']
122
- object = WampClient::Message::Abort.new(*params)
122
+ object = Wamp::Client::Message::Abort.new(*params)
123
123
  payload = object.payload
124
124
 
125
125
  expect(payload.count).to eq(3)
@@ -130,38 +130,38 @@ describe WampClient::Message do
130
130
 
131
131
  end
132
132
 
133
- describe WampClient::Message::Goodbye do
133
+ describe Wamp::Client::Message::Goodbye do
134
134
 
135
135
  it 'creates the message object' do
136
136
  params = [{ test: 1 },'string']
137
- object = WampClient::Message::Goodbye.new(*params)
137
+ object = Wamp::Client::Message::Goodbye.new(*params)
138
138
 
139
139
  expect(object.details).to eq({ test: 1 })
140
140
  expect(object.reason).to eq('string')
141
- expect(object.is_a?(WampClient::Message::Goodbye)).to eq(true)
141
+ expect(object.is_a?(Wamp::Client::Message::Goodbye)).to eq(true)
142
142
  end
143
143
 
144
144
  it 'parses the message and creates an object' do
145
145
  params = [6,{ test: 1 },'string']
146
- object = WampClient::Message::Goodbye.parse(params)
146
+ object = Wamp::Client::Message::Goodbye.parse(params)
147
147
 
148
148
  expect(object.details).to eq({ test: 1 })
149
149
  expect(object.reason).to eq('string')
150
- expect(object.is_a?(WampClient::Message::Goodbye)).to eq(true)
150
+ expect(object.is_a?(Wamp::Client::Message::Goodbye)).to eq(true)
151
151
  end
152
152
 
153
153
  it 'globally parses the message and creates an object' do
154
154
  params = [6,{ test: 1 },'string']
155
- object = WampClient::Message::Base.parse(params)
155
+ object = Wamp::Client::Message::Base.parse(params)
156
156
 
157
157
  expect(object.details).to eq({ test: 1 })
158
158
  expect(object.reason).to eq('string')
159
- expect(object.is_a?(WampClient::Message::Goodbye)).to eq(true)
159
+ expect(object.is_a?(Wamp::Client::Message::Goodbye)).to eq(true)
160
160
  end
161
161
 
162
162
  it 'generates the payload' do
163
163
  params = [{ test: 1 },'string']
164
- object = WampClient::Message::Goodbye.new(*params)
164
+ object = Wamp::Client::Message::Goodbye.new(*params)
165
165
  payload = object.payload
166
166
 
167
167
  expect(payload.count).to eq(3)
@@ -172,44 +172,44 @@ describe WampClient::Message do
172
172
 
173
173
  end
174
174
 
175
- describe WampClient::Message::Error do
175
+ describe Wamp::Client::Message::Error do
176
176
 
177
177
  it 'creates the message object' do
178
178
  params = [123,123,{ test: 1 },'string']
179
- object = WampClient::Message::Error.new(*params)
179
+ object = Wamp::Client::Message::Error.new(*params)
180
180
 
181
181
  expect(object.request_type).to eq(123)
182
182
  expect(object.request_request).to eq(123)
183
183
  expect(object.details).to eq({ test: 1 })
184
184
  expect(object.error).to eq('string')
185
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
185
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
186
186
  end
187
187
 
188
188
  it 'parses the message and creates an object' do
189
189
  params = [8,123,123,{ test: 1 },'string']
190
- object = WampClient::Message::Error.parse(params)
190
+ object = Wamp::Client::Message::Error.parse(params)
191
191
 
192
192
  expect(object.request_type).to eq(123)
193
193
  expect(object.request_request).to eq(123)
194
194
  expect(object.details).to eq({ test: 1 })
195
195
  expect(object.error).to eq('string')
196
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
196
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
197
197
  end
198
198
 
199
199
  it 'globally parses the message and creates an object' do
200
200
  params = [8,123,123,{ test: 1 },'string']
201
- object = WampClient::Message::Base.parse(params)
201
+ object = Wamp::Client::Message::Base.parse(params)
202
202
 
203
203
  expect(object.request_type).to eq(123)
204
204
  expect(object.request_request).to eq(123)
205
205
  expect(object.details).to eq({ test: 1 })
206
206
  expect(object.error).to eq('string')
207
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
207
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
208
208
  end
209
209
 
210
210
  it 'generates the payload' do
211
211
  params = [123,123,{ test: 1 },'string']
212
- object = WampClient::Message::Error.new(*params)
212
+ object = Wamp::Client::Message::Error.new(*params)
213
213
  payload = object.payload
214
214
 
215
215
  expect(payload.count).to eq(5)
@@ -224,21 +224,21 @@ describe WampClient::Message do
224
224
 
225
225
  it 'creates the message object' do
226
226
  params = [123,123,{ test: 1 },'string',['test']]
227
- object = WampClient::Message::Error.new(*params)
227
+ object = Wamp::Client::Message::Error.new(*params)
228
228
 
229
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
229
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
230
230
  end
231
231
 
232
232
  it 'parses the message and creates an object' do
233
233
  params = [8,123,123,{ test: 1 },'string',['test']]
234
- object = WampClient::Message::Error.parse(params)
234
+ object = Wamp::Client::Message::Error.parse(params)
235
235
 
236
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
236
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
237
237
  end
238
238
 
239
239
  it 'generates the payload' do
240
240
  params = [123,123,{ test: 1 },'string',['test']]
241
- object = WampClient::Message::Error.new(*params)
241
+ object = Wamp::Client::Message::Error.new(*params)
242
242
  payload = object.payload
243
243
 
244
244
  expect(payload.count).to eq(6)
@@ -256,21 +256,21 @@ describe WampClient::Message do
256
256
 
257
257
  it 'creates the message object' do
258
258
  params = [123,123,{ test: 1 },'string',[],{ test: 1 }]
259
- object = WampClient::Message::Error.new(*params)
259
+ object = Wamp::Client::Message::Error.new(*params)
260
260
 
261
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
261
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
262
262
  end
263
263
 
264
264
  it 'parses the message and creates an object' do
265
265
  params = [8,123,123,{ test: 1 },'string',[],{ test: 1 }]
266
- object = WampClient::Message::Error.parse(params)
266
+ object = Wamp::Client::Message::Error.parse(params)
267
267
 
268
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
268
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
269
269
  end
270
270
 
271
271
  it 'generates the payload' do
272
272
  params = [123,123,{ test: 1 },'string',[],{ test: 1 }]
273
- object = WampClient::Message::Error.new(*params)
273
+ object = Wamp::Client::Message::Error.new(*params)
274
274
  payload = object.payload
275
275
 
276
276
  expect(payload.count).to eq(7)
@@ -289,21 +289,21 @@ describe WampClient::Message do
289
289
 
290
290
  it 'creates the message object' do
291
291
  params = [123,123,{ test: 1 },'string',[],{}]
292
- object = WampClient::Message::Error.new(*params)
292
+ object = Wamp::Client::Message::Error.new(*params)
293
293
 
294
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
294
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
295
295
  end
296
296
 
297
297
  it 'parses the message and creates an object' do
298
298
  params = [8,123,123,{ test: 1 },'string',[],{}]
299
- object = WampClient::Message::Error.parse(params)
299
+ object = Wamp::Client::Message::Error.parse(params)
300
300
 
301
- expect(object.is_a?(WampClient::Message::Error)).to eq(true)
301
+ expect(object.is_a?(Wamp::Client::Message::Error)).to eq(true)
302
302
  end
303
303
 
304
304
  it 'generates the payload' do
305
305
  params = [123,123,{ test: 1 },'string',[],{}]
306
- object = WampClient::Message::Error.new(*params)
306
+ object = Wamp::Client::Message::Error.new(*params)
307
307
  payload = object.payload
308
308
 
309
309
  expect(payload.count).to eq(5)
@@ -318,41 +318,41 @@ describe WampClient::Message do
318
318
 
319
319
  end
320
320
 
321
- describe WampClient::Message::Publish do
321
+ describe Wamp::Client::Message::Publish do
322
322
 
323
323
  it 'creates the message object' do
324
324
  params = [123,{ test: 1 },'string']
325
- object = WampClient::Message::Publish.new(*params)
325
+ object = Wamp::Client::Message::Publish.new(*params)
326
326
 
327
327
  expect(object.request).to eq(123)
328
328
  expect(object.options).to eq({ test: 1 })
329
329
  expect(object.topic).to eq('string')
330
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
330
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
331
331
  end
332
332
 
333
333
  it 'parses the message and creates an object' do
334
334
  params = [16,123,{ test: 1 },'string']
335
- object = WampClient::Message::Publish.parse(params)
335
+ object = Wamp::Client::Message::Publish.parse(params)
336
336
 
337
337
  expect(object.request).to eq(123)
338
338
  expect(object.options).to eq({ test: 1 })
339
339
  expect(object.topic).to eq('string')
340
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
340
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
341
341
  end
342
342
 
343
343
  it 'globally parses the message and creates an object' do
344
344
  params = [16,123,{ test: 1 },'string']
345
- object = WampClient::Message::Base.parse(params)
345
+ object = Wamp::Client::Message::Base.parse(params)
346
346
 
347
347
  expect(object.request).to eq(123)
348
348
  expect(object.options).to eq({ test: 1 })
349
349
  expect(object.topic).to eq('string')
350
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
350
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
351
351
  end
352
352
 
353
353
  it 'generates the payload' do
354
354
  params = [123,{ test: 1 },'string']
355
- object = WampClient::Message::Publish.new(*params)
355
+ object = Wamp::Client::Message::Publish.new(*params)
356
356
  payload = object.payload
357
357
 
358
358
  expect(payload.count).to eq(4)
@@ -366,21 +366,21 @@ describe WampClient::Message do
366
366
 
367
367
  it 'creates the message object' do
368
368
  params = [123,{ test: 1 },'string',['test']]
369
- object = WampClient::Message::Publish.new(*params)
369
+ object = Wamp::Client::Message::Publish.new(*params)
370
370
 
371
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
371
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
372
372
  end
373
373
 
374
374
  it 'parses the message and creates an object' do
375
375
  params = [16,123,{ test: 1 },'string',['test']]
376
- object = WampClient::Message::Publish.parse(params)
376
+ object = Wamp::Client::Message::Publish.parse(params)
377
377
 
378
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
378
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
379
379
  end
380
380
 
381
381
  it 'generates the payload' do
382
382
  params = [123,{ test: 1 },'string',['test']]
383
- object = WampClient::Message::Publish.new(*params)
383
+ object = Wamp::Client::Message::Publish.new(*params)
384
384
  payload = object.payload
385
385
 
386
386
  expect(payload.count).to eq(5)
@@ -397,21 +397,21 @@ describe WampClient::Message do
397
397
 
398
398
  it 'creates the message object' do
399
399
  params = [123,{ test: 1 },'string',[],{ test: 1 }]
400
- object = WampClient::Message::Publish.new(*params)
400
+ object = Wamp::Client::Message::Publish.new(*params)
401
401
 
402
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
402
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
403
403
  end
404
404
 
405
405
  it 'parses the message and creates an object' do
406
406
  params = [16,123,{ test: 1 },'string',[],{ test: 1 }]
407
- object = WampClient::Message::Publish.parse(params)
407
+ object = Wamp::Client::Message::Publish.parse(params)
408
408
 
409
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
409
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
410
410
  end
411
411
 
412
412
  it 'generates the payload' do
413
413
  params = [123,{ test: 1 },'string',[],{ test: 1 }]
414
- object = WampClient::Message::Publish.new(*params)
414
+ object = Wamp::Client::Message::Publish.new(*params)
415
415
  payload = object.payload
416
416
 
417
417
  expect(payload.count).to eq(6)
@@ -429,21 +429,21 @@ describe WampClient::Message do
429
429
 
430
430
  it 'creates the message object' do
431
431
  params = [123,{ test: 1 },'string',[],{}]
432
- object = WampClient::Message::Publish.new(*params)
432
+ object = Wamp::Client::Message::Publish.new(*params)
433
433
 
434
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
434
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
435
435
  end
436
436
 
437
437
  it 'parses the message and creates an object' do
438
438
  params = [16,123,{ test: 1 },'string',[],{}]
439
- object = WampClient::Message::Publish.parse(params)
439
+ object = Wamp::Client::Message::Publish.parse(params)
440
440
 
441
- expect(object.is_a?(WampClient::Message::Publish)).to eq(true)
441
+ expect(object.is_a?(Wamp::Client::Message::Publish)).to eq(true)
442
442
  end
443
443
 
444
444
  it 'generates the payload' do
445
445
  params = [123,{ test: 1 },'string',[],{}]
446
- object = WampClient::Message::Publish.new(*params)
446
+ object = Wamp::Client::Message::Publish.new(*params)
447
447
  payload = object.payload
448
448
 
449
449
  expect(payload.count).to eq(4)
@@ -457,38 +457,38 @@ describe WampClient::Message do
457
457
 
458
458
  end
459
459
 
460
- describe WampClient::Message::Published do
460
+ describe Wamp::Client::Message::Published do
461
461
 
462
462
  it 'creates the message object' do
463
463
  params = [123,123]
464
- object = WampClient::Message::Published.new(*params)
464
+ object = Wamp::Client::Message::Published.new(*params)
465
465
 
466
466
  expect(object.publish_request).to eq(123)
467
467
  expect(object.publication).to eq(123)
468
- expect(object.is_a?(WampClient::Message::Published)).to eq(true)
468
+ expect(object.is_a?(Wamp::Client::Message::Published)).to eq(true)
469
469
  end
470
470
 
471
471
  it 'parses the message and creates an object' do
472
472
  params = [17,123,123]
473
- object = WampClient::Message::Published.parse(params)
473
+ object = Wamp::Client::Message::Published.parse(params)
474
474
 
475
475
  expect(object.publish_request).to eq(123)
476
476
  expect(object.publication).to eq(123)
477
- expect(object.is_a?(WampClient::Message::Published)).to eq(true)
477
+ expect(object.is_a?(Wamp::Client::Message::Published)).to eq(true)
478
478
  end
479
479
 
480
480
  it 'globally parses the message and creates an object' do
481
481
  params = [17,123,123]
482
- object = WampClient::Message::Base.parse(params)
482
+ object = Wamp::Client::Message::Base.parse(params)
483
483
 
484
484
  expect(object.publish_request).to eq(123)
485
485
  expect(object.publication).to eq(123)
486
- expect(object.is_a?(WampClient::Message::Published)).to eq(true)
486
+ expect(object.is_a?(Wamp::Client::Message::Published)).to eq(true)
487
487
  end
488
488
 
489
489
  it 'generates the payload' do
490
490
  params = [123,123]
491
- object = WampClient::Message::Published.new(*params)
491
+ object = Wamp::Client::Message::Published.new(*params)
492
492
  payload = object.payload
493
493
 
494
494
  expect(payload.count).to eq(3)
@@ -499,41 +499,41 @@ describe WampClient::Message do
499
499
 
500
500
  end
501
501
 
502
- describe WampClient::Message::Subscribe do
502
+ describe Wamp::Client::Message::Subscribe do
503
503
 
504
504
  it 'creates the message object' do
505
505
  params = [123,{ test: 1 },'string']
506
- object = WampClient::Message::Subscribe.new(*params)
506
+ object = Wamp::Client::Message::Subscribe.new(*params)
507
507
 
508
508
  expect(object.request).to eq(123)
509
509
  expect(object.options).to eq({ test: 1 })
510
510
  expect(object.topic).to eq('string')
511
- expect(object.is_a?(WampClient::Message::Subscribe)).to eq(true)
511
+ expect(object.is_a?(Wamp::Client::Message::Subscribe)).to eq(true)
512
512
  end
513
513
 
514
514
  it 'parses the message and creates an object' do
515
515
  params = [32,123,{ test: 1 },'string']
516
- object = WampClient::Message::Subscribe.parse(params)
516
+ object = Wamp::Client::Message::Subscribe.parse(params)
517
517
 
518
518
  expect(object.request).to eq(123)
519
519
  expect(object.options).to eq({ test: 1 })
520
520
  expect(object.topic).to eq('string')
521
- expect(object.is_a?(WampClient::Message::Subscribe)).to eq(true)
521
+ expect(object.is_a?(Wamp::Client::Message::Subscribe)).to eq(true)
522
522
  end
523
523
 
524
524
  it 'globally parses the message and creates an object' do
525
525
  params = [32,123,{ test: 1 },'string']
526
- object = WampClient::Message::Base.parse(params)
526
+ object = Wamp::Client::Message::Base.parse(params)
527
527
 
528
528
  expect(object.request).to eq(123)
529
529
  expect(object.options).to eq({ test: 1 })
530
530
  expect(object.topic).to eq('string')
531
- expect(object.is_a?(WampClient::Message::Subscribe)).to eq(true)
531
+ expect(object.is_a?(Wamp::Client::Message::Subscribe)).to eq(true)
532
532
  end
533
533
 
534
534
  it 'generates the payload' do
535
535
  params = [123,{ test: 1 },'string']
536
- object = WampClient::Message::Subscribe.new(*params)
536
+ object = Wamp::Client::Message::Subscribe.new(*params)
537
537
  payload = object.payload
538
538
 
539
539
  expect(payload.count).to eq(4)
@@ -545,38 +545,38 @@ describe WampClient::Message do
545
545
 
546
546
  end
547
547
 
548
- describe WampClient::Message::Subscribed do
548
+ describe Wamp::Client::Message::Subscribed do
549
549
 
550
550
  it 'creates the message object' do
551
551
  params = [123,123]
552
- object = WampClient::Message::Subscribed.new(*params)
552
+ object = Wamp::Client::Message::Subscribed.new(*params)
553
553
 
554
554
  expect(object.subscribe_request).to eq(123)
555
555
  expect(object.subscription).to eq(123)
556
- expect(object.is_a?(WampClient::Message::Subscribed)).to eq(true)
556
+ expect(object.is_a?(Wamp::Client::Message::Subscribed)).to eq(true)
557
557
  end
558
558
 
559
559
  it 'parses the message and creates an object' do
560
560
  params = [33,123,123]
561
- object = WampClient::Message::Subscribed.parse(params)
561
+ object = Wamp::Client::Message::Subscribed.parse(params)
562
562
 
563
563
  expect(object.subscribe_request).to eq(123)
564
564
  expect(object.subscription).to eq(123)
565
- expect(object.is_a?(WampClient::Message::Subscribed)).to eq(true)
565
+ expect(object.is_a?(Wamp::Client::Message::Subscribed)).to eq(true)
566
566
  end
567
567
 
568
568
  it 'globally parses the message and creates an object' do
569
569
  params = [33,123,123]
570
- object = WampClient::Message::Base.parse(params)
570
+ object = Wamp::Client::Message::Base.parse(params)
571
571
 
572
572
  expect(object.subscribe_request).to eq(123)
573
573
  expect(object.subscription).to eq(123)
574
- expect(object.is_a?(WampClient::Message::Subscribed)).to eq(true)
574
+ expect(object.is_a?(Wamp::Client::Message::Subscribed)).to eq(true)
575
575
  end
576
576
 
577
577
  it 'generates the payload' do
578
578
  params = [123,123]
579
- object = WampClient::Message::Subscribed.new(*params)
579
+ object = Wamp::Client::Message::Subscribed.new(*params)
580
580
  payload = object.payload
581
581
 
582
582
  expect(payload.count).to eq(3)
@@ -587,38 +587,38 @@ describe WampClient::Message do
587
587
 
588
588
  end
589
589
 
590
- describe WampClient::Message::Unsubscribe do
590
+ describe Wamp::Client::Message::Unsubscribe do
591
591
 
592
592
  it 'creates the message object' do
593
593
  params = [123,123]
594
- object = WampClient::Message::Unsubscribe.new(*params)
594
+ object = Wamp::Client::Message::Unsubscribe.new(*params)
595
595
 
596
596
  expect(object.request).to eq(123)
597
597
  expect(object.subscribed_subscription).to eq(123)
598
- expect(object.is_a?(WampClient::Message::Unsubscribe)).to eq(true)
598
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribe)).to eq(true)
599
599
  end
600
600
 
601
601
  it 'parses the message and creates an object' do
602
602
  params = [34,123,123]
603
- object = WampClient::Message::Unsubscribe.parse(params)
603
+ object = Wamp::Client::Message::Unsubscribe.parse(params)
604
604
 
605
605
  expect(object.request).to eq(123)
606
606
  expect(object.subscribed_subscription).to eq(123)
607
- expect(object.is_a?(WampClient::Message::Unsubscribe)).to eq(true)
607
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribe)).to eq(true)
608
608
  end
609
609
 
610
610
  it 'globally parses the message and creates an object' do
611
611
  params = [34,123,123]
612
- object = WampClient::Message::Base.parse(params)
612
+ object = Wamp::Client::Message::Base.parse(params)
613
613
 
614
614
  expect(object.request).to eq(123)
615
615
  expect(object.subscribed_subscription).to eq(123)
616
- expect(object.is_a?(WampClient::Message::Unsubscribe)).to eq(true)
616
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribe)).to eq(true)
617
617
  end
618
618
 
619
619
  it 'generates the payload' do
620
620
  params = [123,123]
621
- object = WampClient::Message::Unsubscribe.new(*params)
621
+ object = Wamp::Client::Message::Unsubscribe.new(*params)
622
622
  payload = object.payload
623
623
 
624
624
  expect(payload.count).to eq(3)
@@ -629,35 +629,35 @@ describe WampClient::Message do
629
629
 
630
630
  end
631
631
 
632
- describe WampClient::Message::Unsubscribed do
632
+ describe Wamp::Client::Message::Unsubscribed do
633
633
 
634
634
  it 'creates the message object' do
635
635
  params = [123]
636
- object = WampClient::Message::Unsubscribed.new(*params)
636
+ object = Wamp::Client::Message::Unsubscribed.new(*params)
637
637
 
638
638
  expect(object.unsubscribe_request).to eq(123)
639
- expect(object.is_a?(WampClient::Message::Unsubscribed)).to eq(true)
639
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribed)).to eq(true)
640
640
  end
641
641
 
642
642
  it 'parses the message and creates an object' do
643
643
  params = [35,123]
644
- object = WampClient::Message::Unsubscribed.parse(params)
644
+ object = Wamp::Client::Message::Unsubscribed.parse(params)
645
645
 
646
646
  expect(object.unsubscribe_request).to eq(123)
647
- expect(object.is_a?(WampClient::Message::Unsubscribed)).to eq(true)
647
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribed)).to eq(true)
648
648
  end
649
649
 
650
650
  it 'globally parses the message and creates an object' do
651
651
  params = [35,123]
652
- object = WampClient::Message::Base.parse(params)
652
+ object = Wamp::Client::Message::Base.parse(params)
653
653
 
654
654
  expect(object.unsubscribe_request).to eq(123)
655
- expect(object.is_a?(WampClient::Message::Unsubscribed)).to eq(true)
655
+ expect(object.is_a?(Wamp::Client::Message::Unsubscribed)).to eq(true)
656
656
  end
657
657
 
658
658
  it 'generates the payload' do
659
659
  params = [123]
660
- object = WampClient::Message::Unsubscribed.new(*params)
660
+ object = Wamp::Client::Message::Unsubscribed.new(*params)
661
661
  payload = object.payload
662
662
 
663
663
  expect(payload.count).to eq(2)
@@ -667,41 +667,41 @@ describe WampClient::Message do
667
667
 
668
668
  end
669
669
 
670
- describe WampClient::Message::Event do
670
+ describe Wamp::Client::Message::Event do
671
671
 
672
672
  it 'creates the message object' do
673
673
  params = [123,123,{ test: 1 }]
674
- object = WampClient::Message::Event.new(*params)
674
+ object = Wamp::Client::Message::Event.new(*params)
675
675
 
676
676
  expect(object.subscribed_subscription).to eq(123)
677
677
  expect(object.published_publication).to eq(123)
678
678
  expect(object.details).to eq({ test: 1 })
679
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
679
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
680
680
  end
681
681
 
682
682
  it 'parses the message and creates an object' do
683
683
  params = [36,123,123,{ test: 1 }]
684
- object = WampClient::Message::Event.parse(params)
684
+ object = Wamp::Client::Message::Event.parse(params)
685
685
 
686
686
  expect(object.subscribed_subscription).to eq(123)
687
687
  expect(object.published_publication).to eq(123)
688
688
  expect(object.details).to eq({ test: 1 })
689
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
689
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
690
690
  end
691
691
 
692
692
  it 'globally parses the message and creates an object' do
693
693
  params = [36,123,123,{ test: 1 }]
694
- object = WampClient::Message::Base.parse(params)
694
+ object = Wamp::Client::Message::Base.parse(params)
695
695
 
696
696
  expect(object.subscribed_subscription).to eq(123)
697
697
  expect(object.published_publication).to eq(123)
698
698
  expect(object.details).to eq({ test: 1 })
699
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
699
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
700
700
  end
701
701
 
702
702
  it 'generates the payload' do
703
703
  params = [123,123,{ test: 1 }]
704
- object = WampClient::Message::Event.new(*params)
704
+ object = Wamp::Client::Message::Event.new(*params)
705
705
  payload = object.payload
706
706
 
707
707
  expect(payload.count).to eq(4)
@@ -715,21 +715,21 @@ describe WampClient::Message do
715
715
 
716
716
  it 'creates the message object' do
717
717
  params = [123,123,{ test: 1 },['test']]
718
- object = WampClient::Message::Event.new(*params)
718
+ object = Wamp::Client::Message::Event.new(*params)
719
719
 
720
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
720
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
721
721
  end
722
722
 
723
723
  it 'parses the message and creates an object' do
724
724
  params = [36,123,123,{ test: 1 },['test']]
725
- object = WampClient::Message::Event.parse(params)
725
+ object = Wamp::Client::Message::Event.parse(params)
726
726
 
727
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
727
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
728
728
  end
729
729
 
730
730
  it 'generates the payload' do
731
731
  params = [123,123,{ test: 1 },['test']]
732
- object = WampClient::Message::Event.new(*params)
732
+ object = Wamp::Client::Message::Event.new(*params)
733
733
  payload = object.payload
734
734
 
735
735
  expect(payload.count).to eq(5)
@@ -746,21 +746,21 @@ describe WampClient::Message do
746
746
 
747
747
  it 'creates the message object' do
748
748
  params = [123,123,{ test: 1 },[],{ test: 1 }]
749
- object = WampClient::Message::Event.new(*params)
749
+ object = Wamp::Client::Message::Event.new(*params)
750
750
 
751
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
751
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
752
752
  end
753
753
 
754
754
  it 'parses the message and creates an object' do
755
755
  params = [36,123,123,{ test: 1 },[],{ test: 1 }]
756
- object = WampClient::Message::Event.parse(params)
756
+ object = Wamp::Client::Message::Event.parse(params)
757
757
 
758
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
758
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
759
759
  end
760
760
 
761
761
  it 'generates the payload' do
762
762
  params = [123,123,{ test: 1 },[],{ test: 1 }]
763
- object = WampClient::Message::Event.new(*params)
763
+ object = Wamp::Client::Message::Event.new(*params)
764
764
  payload = object.payload
765
765
 
766
766
  expect(payload.count).to eq(6)
@@ -778,21 +778,21 @@ describe WampClient::Message do
778
778
 
779
779
  it 'creates the message object' do
780
780
  params = [123,123,{ test: 1 },[],{}]
781
- object = WampClient::Message::Event.new(*params)
781
+ object = Wamp::Client::Message::Event.new(*params)
782
782
 
783
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
783
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
784
784
  end
785
785
 
786
786
  it 'parses the message and creates an object' do
787
787
  params = [36,123,123,{ test: 1 },[],{}]
788
- object = WampClient::Message::Event.parse(params)
788
+ object = Wamp::Client::Message::Event.parse(params)
789
789
 
790
- expect(object.is_a?(WampClient::Message::Event)).to eq(true)
790
+ expect(object.is_a?(Wamp::Client::Message::Event)).to eq(true)
791
791
  end
792
792
 
793
793
  it 'generates the payload' do
794
794
  params = [123,123,{ test: 1 },[],{}]
795
- object = WampClient::Message::Event.new(*params)
795
+ object = Wamp::Client::Message::Event.new(*params)
796
796
  payload = object.payload
797
797
 
798
798
  expect(payload.count).to eq(4)
@@ -806,41 +806,41 @@ describe WampClient::Message do
806
806
 
807
807
  end
808
808
 
809
- describe WampClient::Message::Call do
809
+ describe Wamp::Client::Message::Call do
810
810
 
811
811
  it 'creates the message object' do
812
812
  params = [123,{ test: 1 },'string']
813
- object = WampClient::Message::Call.new(*params)
813
+ object = Wamp::Client::Message::Call.new(*params)
814
814
 
815
815
  expect(object.request).to eq(123)
816
816
  expect(object.options).to eq({ test: 1 })
817
817
  expect(object.procedure).to eq('string')
818
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
818
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
819
819
  end
820
820
 
821
821
  it 'parses the message and creates an object' do
822
822
  params = [48,123,{ test: 1 },'string']
823
- object = WampClient::Message::Call.parse(params)
823
+ object = Wamp::Client::Message::Call.parse(params)
824
824
 
825
825
  expect(object.request).to eq(123)
826
826
  expect(object.options).to eq({ test: 1 })
827
827
  expect(object.procedure).to eq('string')
828
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
828
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
829
829
  end
830
830
 
831
831
  it 'globally parses the message and creates an object' do
832
832
  params = [48,123,{ test: 1 },'string']
833
- object = WampClient::Message::Base.parse(params)
833
+ object = Wamp::Client::Message::Base.parse(params)
834
834
 
835
835
  expect(object.request).to eq(123)
836
836
  expect(object.options).to eq({ test: 1 })
837
837
  expect(object.procedure).to eq('string')
838
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
838
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
839
839
  end
840
840
 
841
841
  it 'generates the payload' do
842
842
  params = [123,{ test: 1 },'string']
843
- object = WampClient::Message::Call.new(*params)
843
+ object = Wamp::Client::Message::Call.new(*params)
844
844
  payload = object.payload
845
845
 
846
846
  expect(payload.count).to eq(4)
@@ -854,21 +854,21 @@ describe WampClient::Message do
854
854
 
855
855
  it 'creates the message object' do
856
856
  params = [123,{ test: 1 },'string',['test']]
857
- object = WampClient::Message::Call.new(*params)
857
+ object = Wamp::Client::Message::Call.new(*params)
858
858
 
859
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
859
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
860
860
  end
861
861
 
862
862
  it 'parses the message and creates an object' do
863
863
  params = [48,123,{ test: 1 },'string',['test']]
864
- object = WampClient::Message::Call.parse(params)
864
+ object = Wamp::Client::Message::Call.parse(params)
865
865
 
866
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
866
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
867
867
  end
868
868
 
869
869
  it 'generates the payload' do
870
870
  params = [123,{ test: 1 },'string',['test']]
871
- object = WampClient::Message::Call.new(*params)
871
+ object = Wamp::Client::Message::Call.new(*params)
872
872
  payload = object.payload
873
873
 
874
874
  expect(payload.count).to eq(5)
@@ -885,21 +885,21 @@ describe WampClient::Message do
885
885
 
886
886
  it 'creates the message object' do
887
887
  params = [123,{ test: 1 },'string',[],{ test: 1 }]
888
- object = WampClient::Message::Call.new(*params)
888
+ object = Wamp::Client::Message::Call.new(*params)
889
889
 
890
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
890
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
891
891
  end
892
892
 
893
893
  it 'parses the message and creates an object' do
894
894
  params = [48,123,{ test: 1 },'string',[],{ test: 1 }]
895
- object = WampClient::Message::Call.parse(params)
895
+ object = Wamp::Client::Message::Call.parse(params)
896
896
 
897
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
897
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
898
898
  end
899
899
 
900
900
  it 'generates the payload' do
901
901
  params = [123,{ test: 1 },'string',[],{ test: 1 }]
902
- object = WampClient::Message::Call.new(*params)
902
+ object = Wamp::Client::Message::Call.new(*params)
903
903
  payload = object.payload
904
904
 
905
905
  expect(payload.count).to eq(6)
@@ -917,21 +917,21 @@ describe WampClient::Message do
917
917
 
918
918
  it 'creates the message object' do
919
919
  params = [123,{ test: 1 },'string',[],{}]
920
- object = WampClient::Message::Call.new(*params)
920
+ object = Wamp::Client::Message::Call.new(*params)
921
921
 
922
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
922
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
923
923
  end
924
924
 
925
925
  it 'parses the message and creates an object' do
926
926
  params = [48,123,{ test: 1 },'string',[],{}]
927
- object = WampClient::Message::Call.parse(params)
927
+ object = Wamp::Client::Message::Call.parse(params)
928
928
 
929
- expect(object.is_a?(WampClient::Message::Call)).to eq(true)
929
+ expect(object.is_a?(Wamp::Client::Message::Call)).to eq(true)
930
930
  end
931
931
 
932
932
  it 'generates the payload' do
933
933
  params = [123,{ test: 1 },'string',[],{}]
934
- object = WampClient::Message::Call.new(*params)
934
+ object = Wamp::Client::Message::Call.new(*params)
935
935
  payload = object.payload
936
936
 
937
937
  expect(payload.count).to eq(4)
@@ -945,38 +945,38 @@ describe WampClient::Message do
945
945
 
946
946
  end
947
947
 
948
- describe WampClient::Message::Result do
948
+ describe Wamp::Client::Message::Result do
949
949
 
950
950
  it 'creates the message object' do
951
951
  params = [123,{ test: 1 }]
952
- object = WampClient::Message::Result.new(*params)
952
+ object = Wamp::Client::Message::Result.new(*params)
953
953
 
954
954
  expect(object.call_request).to eq(123)
955
955
  expect(object.details).to eq({ test: 1 })
956
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
956
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
957
957
  end
958
958
 
959
959
  it 'parses the message and creates an object' do
960
960
  params = [50,123,{ test: 1 }]
961
- object = WampClient::Message::Result.parse(params)
961
+ object = Wamp::Client::Message::Result.parse(params)
962
962
 
963
963
  expect(object.call_request).to eq(123)
964
964
  expect(object.details).to eq({ test: 1 })
965
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
965
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
966
966
  end
967
967
 
968
968
  it 'globally parses the message and creates an object' do
969
969
  params = [50,123,{ test: 1 }]
970
- object = WampClient::Message::Base.parse(params)
970
+ object = Wamp::Client::Message::Base.parse(params)
971
971
 
972
972
  expect(object.call_request).to eq(123)
973
973
  expect(object.details).to eq({ test: 1 })
974
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
974
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
975
975
  end
976
976
 
977
977
  it 'generates the payload' do
978
978
  params = [123,{ test: 1 }]
979
- object = WampClient::Message::Result.new(*params)
979
+ object = Wamp::Client::Message::Result.new(*params)
980
980
  payload = object.payload
981
981
 
982
982
  expect(payload.count).to eq(3)
@@ -989,21 +989,21 @@ describe WampClient::Message do
989
989
 
990
990
  it 'creates the message object' do
991
991
  params = [123,{ test: 1 },['test']]
992
- object = WampClient::Message::Result.new(*params)
992
+ object = Wamp::Client::Message::Result.new(*params)
993
993
 
994
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
994
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
995
995
  end
996
996
 
997
997
  it 'parses the message and creates an object' do
998
998
  params = [50,123,{ test: 1 },['test']]
999
- object = WampClient::Message::Result.parse(params)
999
+ object = Wamp::Client::Message::Result.parse(params)
1000
1000
 
1001
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
1001
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
1002
1002
  end
1003
1003
 
1004
1004
  it 'generates the payload' do
1005
1005
  params = [123,{ test: 1 },['test']]
1006
- object = WampClient::Message::Result.new(*params)
1006
+ object = Wamp::Client::Message::Result.new(*params)
1007
1007
  payload = object.payload
1008
1008
 
1009
1009
  expect(payload.count).to eq(4)
@@ -1019,21 +1019,21 @@ describe WampClient::Message do
1019
1019
 
1020
1020
  it 'creates the message object' do
1021
1021
  params = [123,{ test: 1 },[],{ test: 1 }]
1022
- object = WampClient::Message::Result.new(*params)
1022
+ object = Wamp::Client::Message::Result.new(*params)
1023
1023
 
1024
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
1024
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
1025
1025
  end
1026
1026
 
1027
1027
  it 'parses the message and creates an object' do
1028
1028
  params = [50,123,{ test: 1 },[],{ test: 1 }]
1029
- object = WampClient::Message::Result.parse(params)
1029
+ object = Wamp::Client::Message::Result.parse(params)
1030
1030
 
1031
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
1031
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
1032
1032
  end
1033
1033
 
1034
1034
  it 'generates the payload' do
1035
1035
  params = [123,{ test: 1 },[],{ test: 1 }]
1036
- object = WampClient::Message::Result.new(*params)
1036
+ object = Wamp::Client::Message::Result.new(*params)
1037
1037
  payload = object.payload
1038
1038
 
1039
1039
  expect(payload.count).to eq(5)
@@ -1050,21 +1050,21 @@ describe WampClient::Message do
1050
1050
 
1051
1051
  it 'creates the message object' do
1052
1052
  params = [123,{ test: 1 },[],{}]
1053
- object = WampClient::Message::Result.new(*params)
1053
+ object = Wamp::Client::Message::Result.new(*params)
1054
1054
 
1055
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
1055
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
1056
1056
  end
1057
1057
 
1058
1058
  it 'parses the message and creates an object' do
1059
1059
  params = [50,123,{ test: 1 },[],{}]
1060
- object = WampClient::Message::Result.parse(params)
1060
+ object = Wamp::Client::Message::Result.parse(params)
1061
1061
 
1062
- expect(object.is_a?(WampClient::Message::Result)).to eq(true)
1062
+ expect(object.is_a?(Wamp::Client::Message::Result)).to eq(true)
1063
1063
  end
1064
1064
 
1065
1065
  it 'generates the payload' do
1066
1066
  params = [123,{ test: 1 },[],{}]
1067
- object = WampClient::Message::Result.new(*params)
1067
+ object = Wamp::Client::Message::Result.new(*params)
1068
1068
  payload = object.payload
1069
1069
 
1070
1070
  expect(payload.count).to eq(3)
@@ -1077,41 +1077,41 @@ describe WampClient::Message do
1077
1077
 
1078
1078
  end
1079
1079
 
1080
- describe WampClient::Message::Register do
1080
+ describe Wamp::Client::Message::Register do
1081
1081
 
1082
1082
  it 'creates the message object' do
1083
1083
  params = [123,{ test: 1 },'string']
1084
- object = WampClient::Message::Register.new(*params)
1084
+ object = Wamp::Client::Message::Register.new(*params)
1085
1085
 
1086
1086
  expect(object.request).to eq(123)
1087
1087
  expect(object.options).to eq({ test: 1 })
1088
1088
  expect(object.procedure).to eq('string')
1089
- expect(object.is_a?(WampClient::Message::Register)).to eq(true)
1089
+ expect(object.is_a?(Wamp::Client::Message::Register)).to eq(true)
1090
1090
  end
1091
1091
 
1092
1092
  it 'parses the message and creates an object' do
1093
1093
  params = [64,123,{ test: 1 },'string']
1094
- object = WampClient::Message::Register.parse(params)
1094
+ object = Wamp::Client::Message::Register.parse(params)
1095
1095
 
1096
1096
  expect(object.request).to eq(123)
1097
1097
  expect(object.options).to eq({ test: 1 })
1098
1098
  expect(object.procedure).to eq('string')
1099
- expect(object.is_a?(WampClient::Message::Register)).to eq(true)
1099
+ expect(object.is_a?(Wamp::Client::Message::Register)).to eq(true)
1100
1100
  end
1101
1101
 
1102
1102
  it 'globally parses the message and creates an object' do
1103
1103
  params = [64,123,{ test: 1 },'string']
1104
- object = WampClient::Message::Base.parse(params)
1104
+ object = Wamp::Client::Message::Base.parse(params)
1105
1105
 
1106
1106
  expect(object.request).to eq(123)
1107
1107
  expect(object.options).to eq({ test: 1 })
1108
1108
  expect(object.procedure).to eq('string')
1109
- expect(object.is_a?(WampClient::Message::Register)).to eq(true)
1109
+ expect(object.is_a?(Wamp::Client::Message::Register)).to eq(true)
1110
1110
  end
1111
1111
 
1112
1112
  it 'generates the payload' do
1113
1113
  params = [123,{ test: 1 },'string']
1114
- object = WampClient::Message::Register.new(*params)
1114
+ object = Wamp::Client::Message::Register.new(*params)
1115
1115
  payload = object.payload
1116
1116
 
1117
1117
  expect(payload.count).to eq(4)
@@ -1123,38 +1123,38 @@ describe WampClient::Message do
1123
1123
 
1124
1124
  end
1125
1125
 
1126
- describe WampClient::Message::Registered do
1126
+ describe Wamp::Client::Message::Registered do
1127
1127
 
1128
1128
  it 'creates the message object' do
1129
1129
  params = [123,123]
1130
- object = WampClient::Message::Registered.new(*params)
1130
+ object = Wamp::Client::Message::Registered.new(*params)
1131
1131
 
1132
1132
  expect(object.register_request).to eq(123)
1133
1133
  expect(object.registration).to eq(123)
1134
- expect(object.is_a?(WampClient::Message::Registered)).to eq(true)
1134
+ expect(object.is_a?(Wamp::Client::Message::Registered)).to eq(true)
1135
1135
  end
1136
1136
 
1137
1137
  it 'parses the message and creates an object' do
1138
1138
  params = [65,123,123]
1139
- object = WampClient::Message::Registered.parse(params)
1139
+ object = Wamp::Client::Message::Registered.parse(params)
1140
1140
 
1141
1141
  expect(object.register_request).to eq(123)
1142
1142
  expect(object.registration).to eq(123)
1143
- expect(object.is_a?(WampClient::Message::Registered)).to eq(true)
1143
+ expect(object.is_a?(Wamp::Client::Message::Registered)).to eq(true)
1144
1144
  end
1145
1145
 
1146
1146
  it 'globally parses the message and creates an object' do
1147
1147
  params = [65,123,123]
1148
- object = WampClient::Message::Base.parse(params)
1148
+ object = Wamp::Client::Message::Base.parse(params)
1149
1149
 
1150
1150
  expect(object.register_request).to eq(123)
1151
1151
  expect(object.registration).to eq(123)
1152
- expect(object.is_a?(WampClient::Message::Registered)).to eq(true)
1152
+ expect(object.is_a?(Wamp::Client::Message::Registered)).to eq(true)
1153
1153
  end
1154
1154
 
1155
1155
  it 'generates the payload' do
1156
1156
  params = [123,123]
1157
- object = WampClient::Message::Registered.new(*params)
1157
+ object = Wamp::Client::Message::Registered.new(*params)
1158
1158
  payload = object.payload
1159
1159
 
1160
1160
  expect(payload.count).to eq(3)
@@ -1165,38 +1165,38 @@ describe WampClient::Message do
1165
1165
 
1166
1166
  end
1167
1167
 
1168
- describe WampClient::Message::Unregister do
1168
+ describe Wamp::Client::Message::Unregister do
1169
1169
 
1170
1170
  it 'creates the message object' do
1171
1171
  params = [123,123]
1172
- object = WampClient::Message::Unregister.new(*params)
1172
+ object = Wamp::Client::Message::Unregister.new(*params)
1173
1173
 
1174
1174
  expect(object.request).to eq(123)
1175
1175
  expect(object.registered_registration).to eq(123)
1176
- expect(object.is_a?(WampClient::Message::Unregister)).to eq(true)
1176
+ expect(object.is_a?(Wamp::Client::Message::Unregister)).to eq(true)
1177
1177
  end
1178
1178
 
1179
1179
  it 'parses the message and creates an object' do
1180
1180
  params = [66,123,123]
1181
- object = WampClient::Message::Unregister.parse(params)
1181
+ object = Wamp::Client::Message::Unregister.parse(params)
1182
1182
 
1183
1183
  expect(object.request).to eq(123)
1184
1184
  expect(object.registered_registration).to eq(123)
1185
- expect(object.is_a?(WampClient::Message::Unregister)).to eq(true)
1185
+ expect(object.is_a?(Wamp::Client::Message::Unregister)).to eq(true)
1186
1186
  end
1187
1187
 
1188
1188
  it 'globally parses the message and creates an object' do
1189
1189
  params = [66,123,123]
1190
- object = WampClient::Message::Base.parse(params)
1190
+ object = Wamp::Client::Message::Base.parse(params)
1191
1191
 
1192
1192
  expect(object.request).to eq(123)
1193
1193
  expect(object.registered_registration).to eq(123)
1194
- expect(object.is_a?(WampClient::Message::Unregister)).to eq(true)
1194
+ expect(object.is_a?(Wamp::Client::Message::Unregister)).to eq(true)
1195
1195
  end
1196
1196
 
1197
1197
  it 'generates the payload' do
1198
1198
  params = [123,123]
1199
- object = WampClient::Message::Unregister.new(*params)
1199
+ object = Wamp::Client::Message::Unregister.new(*params)
1200
1200
  payload = object.payload
1201
1201
 
1202
1202
  expect(payload.count).to eq(3)
@@ -1207,35 +1207,35 @@ describe WampClient::Message do
1207
1207
 
1208
1208
  end
1209
1209
 
1210
- describe WampClient::Message::Unregistered do
1210
+ describe Wamp::Client::Message::Unregistered do
1211
1211
 
1212
1212
  it 'creates the message object' do
1213
1213
  params = [123]
1214
- object = WampClient::Message::Unregistered.new(*params)
1214
+ object = Wamp::Client::Message::Unregistered.new(*params)
1215
1215
 
1216
1216
  expect(object.unregister_request).to eq(123)
1217
- expect(object.is_a?(WampClient::Message::Unregistered)).to eq(true)
1217
+ expect(object.is_a?(Wamp::Client::Message::Unregistered)).to eq(true)
1218
1218
  end
1219
1219
 
1220
1220
  it 'parses the message and creates an object' do
1221
1221
  params = [67,123]
1222
- object = WampClient::Message::Unregistered.parse(params)
1222
+ object = Wamp::Client::Message::Unregistered.parse(params)
1223
1223
 
1224
1224
  expect(object.unregister_request).to eq(123)
1225
- expect(object.is_a?(WampClient::Message::Unregistered)).to eq(true)
1225
+ expect(object.is_a?(Wamp::Client::Message::Unregistered)).to eq(true)
1226
1226
  end
1227
1227
 
1228
1228
  it 'globally parses the message and creates an object' do
1229
1229
  params = [67,123]
1230
- object = WampClient::Message::Base.parse(params)
1230
+ object = Wamp::Client::Message::Base.parse(params)
1231
1231
 
1232
1232
  expect(object.unregister_request).to eq(123)
1233
- expect(object.is_a?(WampClient::Message::Unregistered)).to eq(true)
1233
+ expect(object.is_a?(Wamp::Client::Message::Unregistered)).to eq(true)
1234
1234
  end
1235
1235
 
1236
1236
  it 'generates the payload' do
1237
1237
  params = [123]
1238
- object = WampClient::Message::Unregistered.new(*params)
1238
+ object = Wamp::Client::Message::Unregistered.new(*params)
1239
1239
  payload = object.payload
1240
1240
 
1241
1241
  expect(payload.count).to eq(2)
@@ -1245,41 +1245,41 @@ describe WampClient::Message do
1245
1245
 
1246
1246
  end
1247
1247
 
1248
- describe WampClient::Message::Invocation do
1248
+ describe Wamp::Client::Message::Invocation do
1249
1249
 
1250
1250
  it 'creates the message object' do
1251
1251
  params = [123,123,{ test: 1 }]
1252
- object = WampClient::Message::Invocation.new(*params)
1252
+ object = Wamp::Client::Message::Invocation.new(*params)
1253
1253
 
1254
1254
  expect(object.request).to eq(123)
1255
1255
  expect(object.registered_registration).to eq(123)
1256
1256
  expect(object.details).to eq({ test: 1 })
1257
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1257
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1258
1258
  end
1259
1259
 
1260
1260
  it 'parses the message and creates an object' do
1261
1261
  params = [68,123,123,{ test: 1 }]
1262
- object = WampClient::Message::Invocation.parse(params)
1262
+ object = Wamp::Client::Message::Invocation.parse(params)
1263
1263
 
1264
1264
  expect(object.request).to eq(123)
1265
1265
  expect(object.registered_registration).to eq(123)
1266
1266
  expect(object.details).to eq({ test: 1 })
1267
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1267
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1268
1268
  end
1269
1269
 
1270
1270
  it 'globally parses the message and creates an object' do
1271
1271
  params = [68,123,123,{ test: 1 }]
1272
- object = WampClient::Message::Base.parse(params)
1272
+ object = Wamp::Client::Message::Base.parse(params)
1273
1273
 
1274
1274
  expect(object.request).to eq(123)
1275
1275
  expect(object.registered_registration).to eq(123)
1276
1276
  expect(object.details).to eq({ test: 1 })
1277
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1277
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1278
1278
  end
1279
1279
 
1280
1280
  it 'generates the payload' do
1281
1281
  params = [123,123,{ test: 1 }]
1282
- object = WampClient::Message::Invocation.new(*params)
1282
+ object = Wamp::Client::Message::Invocation.new(*params)
1283
1283
  payload = object.payload
1284
1284
 
1285
1285
  expect(payload.count).to eq(4)
@@ -1293,21 +1293,21 @@ describe WampClient::Message do
1293
1293
 
1294
1294
  it 'creates the message object' do
1295
1295
  params = [123,123,{ test: 1 },['test']]
1296
- object = WampClient::Message::Invocation.new(*params)
1296
+ object = Wamp::Client::Message::Invocation.new(*params)
1297
1297
 
1298
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1298
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1299
1299
  end
1300
1300
 
1301
1301
  it 'parses the message and creates an object' do
1302
1302
  params = [68,123,123,{ test: 1 },['test']]
1303
- object = WampClient::Message::Invocation.parse(params)
1303
+ object = Wamp::Client::Message::Invocation.parse(params)
1304
1304
 
1305
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1305
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1306
1306
  end
1307
1307
 
1308
1308
  it 'generates the payload' do
1309
1309
  params = [123,123,{ test: 1 },['test']]
1310
- object = WampClient::Message::Invocation.new(*params)
1310
+ object = Wamp::Client::Message::Invocation.new(*params)
1311
1311
  payload = object.payload
1312
1312
 
1313
1313
  expect(payload.count).to eq(5)
@@ -1324,21 +1324,21 @@ describe WampClient::Message do
1324
1324
 
1325
1325
  it 'creates the message object' do
1326
1326
  params = [123,123,{ test: 1 },[],{ test: 1 }]
1327
- object = WampClient::Message::Invocation.new(*params)
1327
+ object = Wamp::Client::Message::Invocation.new(*params)
1328
1328
 
1329
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1329
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1330
1330
  end
1331
1331
 
1332
1332
  it 'parses the message and creates an object' do
1333
1333
  params = [68,123,123,{ test: 1 },[],{ test: 1 }]
1334
- object = WampClient::Message::Invocation.parse(params)
1334
+ object = Wamp::Client::Message::Invocation.parse(params)
1335
1335
 
1336
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1336
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1337
1337
  end
1338
1338
 
1339
1339
  it 'generates the payload' do
1340
1340
  params = [123,123,{ test: 1 },[],{ test: 1 }]
1341
- object = WampClient::Message::Invocation.new(*params)
1341
+ object = Wamp::Client::Message::Invocation.new(*params)
1342
1342
  payload = object.payload
1343
1343
 
1344
1344
  expect(payload.count).to eq(6)
@@ -1356,21 +1356,21 @@ describe WampClient::Message do
1356
1356
 
1357
1357
  it 'creates the message object' do
1358
1358
  params = [123,123,{ test: 1 },[],{}]
1359
- object = WampClient::Message::Invocation.new(*params)
1359
+ object = Wamp::Client::Message::Invocation.new(*params)
1360
1360
 
1361
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1361
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1362
1362
  end
1363
1363
 
1364
1364
  it 'parses the message and creates an object' do
1365
1365
  params = [68,123,123,{ test: 1 },[],{}]
1366
- object = WampClient::Message::Invocation.parse(params)
1366
+ object = Wamp::Client::Message::Invocation.parse(params)
1367
1367
 
1368
- expect(object.is_a?(WampClient::Message::Invocation)).to eq(true)
1368
+ expect(object.is_a?(Wamp::Client::Message::Invocation)).to eq(true)
1369
1369
  end
1370
1370
 
1371
1371
  it 'generates the payload' do
1372
1372
  params = [123,123,{ test: 1 },[],{}]
1373
- object = WampClient::Message::Invocation.new(*params)
1373
+ object = Wamp::Client::Message::Invocation.new(*params)
1374
1374
  payload = object.payload
1375
1375
 
1376
1376
  expect(payload.count).to eq(4)
@@ -1384,38 +1384,38 @@ describe WampClient::Message do
1384
1384
 
1385
1385
  end
1386
1386
 
1387
- describe WampClient::Message::Yield do
1387
+ describe Wamp::Client::Message::Yield do
1388
1388
 
1389
1389
  it 'creates the message object' do
1390
1390
  params = [123,{ test: 1 }]
1391
- object = WampClient::Message::Yield.new(*params)
1391
+ object = Wamp::Client::Message::Yield.new(*params)
1392
1392
 
1393
1393
  expect(object.invocation_request).to eq(123)
1394
1394
  expect(object.options).to eq({ test: 1 })
1395
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1395
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1396
1396
  end
1397
1397
 
1398
1398
  it 'parses the message and creates an object' do
1399
1399
  params = [70,123,{ test: 1 }]
1400
- object = WampClient::Message::Yield.parse(params)
1400
+ object = Wamp::Client::Message::Yield.parse(params)
1401
1401
 
1402
1402
  expect(object.invocation_request).to eq(123)
1403
1403
  expect(object.options).to eq({ test: 1 })
1404
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1404
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1405
1405
  end
1406
1406
 
1407
1407
  it 'globally parses the message and creates an object' do
1408
1408
  params = [70,123,{ test: 1 }]
1409
- object = WampClient::Message::Base.parse(params)
1409
+ object = Wamp::Client::Message::Base.parse(params)
1410
1410
 
1411
1411
  expect(object.invocation_request).to eq(123)
1412
1412
  expect(object.options).to eq({ test: 1 })
1413
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1413
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1414
1414
  end
1415
1415
 
1416
1416
  it 'generates the payload' do
1417
1417
  params = [123,{ test: 1 }]
1418
- object = WampClient::Message::Yield.new(*params)
1418
+ object = Wamp::Client::Message::Yield.new(*params)
1419
1419
  payload = object.payload
1420
1420
 
1421
1421
  expect(payload.count).to eq(3)
@@ -1428,21 +1428,21 @@ describe WampClient::Message do
1428
1428
 
1429
1429
  it 'creates the message object' do
1430
1430
  params = [123,{ test: 1 },['test']]
1431
- object = WampClient::Message::Yield.new(*params)
1431
+ object = Wamp::Client::Message::Yield.new(*params)
1432
1432
 
1433
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1433
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1434
1434
  end
1435
1435
 
1436
1436
  it 'parses the message and creates an object' do
1437
1437
  params = [70,123,{ test: 1 },['test']]
1438
- object = WampClient::Message::Yield.parse(params)
1438
+ object = Wamp::Client::Message::Yield.parse(params)
1439
1439
 
1440
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1440
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1441
1441
  end
1442
1442
 
1443
1443
  it 'generates the payload' do
1444
1444
  params = [123,{ test: 1 },['test']]
1445
- object = WampClient::Message::Yield.new(*params)
1445
+ object = Wamp::Client::Message::Yield.new(*params)
1446
1446
  payload = object.payload
1447
1447
 
1448
1448
  expect(payload.count).to eq(4)
@@ -1458,21 +1458,21 @@ describe WampClient::Message do
1458
1458
 
1459
1459
  it 'creates the message object' do
1460
1460
  params = [123,{ test: 1 },[],{ test: 1 }]
1461
- object = WampClient::Message::Yield.new(*params)
1461
+ object = Wamp::Client::Message::Yield.new(*params)
1462
1462
 
1463
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1463
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1464
1464
  end
1465
1465
 
1466
1466
  it 'parses the message and creates an object' do
1467
1467
  params = [70,123,{ test: 1 },[],{ test: 1 }]
1468
- object = WampClient::Message::Yield.parse(params)
1468
+ object = Wamp::Client::Message::Yield.parse(params)
1469
1469
 
1470
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1470
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1471
1471
  end
1472
1472
 
1473
1473
  it 'generates the payload' do
1474
1474
  params = [123,{ test: 1 },[],{ test: 1 }]
1475
- object = WampClient::Message::Yield.new(*params)
1475
+ object = Wamp::Client::Message::Yield.new(*params)
1476
1476
  payload = object.payload
1477
1477
 
1478
1478
  expect(payload.count).to eq(5)
@@ -1489,21 +1489,21 @@ describe WampClient::Message do
1489
1489
 
1490
1490
  it 'creates the message object' do
1491
1491
  params = [123,{ test: 1 },[],{}]
1492
- object = WampClient::Message::Yield.new(*params)
1492
+ object = Wamp::Client::Message::Yield.new(*params)
1493
1493
 
1494
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1494
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1495
1495
  end
1496
1496
 
1497
1497
  it 'parses the message and creates an object' do
1498
1498
  params = [70,123,{ test: 1 },[],{}]
1499
- object = WampClient::Message::Yield.parse(params)
1499
+ object = Wamp::Client::Message::Yield.parse(params)
1500
1500
 
1501
- expect(object.is_a?(WampClient::Message::Yield)).to eq(true)
1501
+ expect(object.is_a?(Wamp::Client::Message::Yield)).to eq(true)
1502
1502
  end
1503
1503
 
1504
1504
  it 'generates the payload' do
1505
1505
  params = [123,{ test: 1 },[],{}]
1506
- object = WampClient::Message::Yield.new(*params)
1506
+ object = Wamp::Client::Message::Yield.new(*params)
1507
1507
  payload = object.payload
1508
1508
 
1509
1509
  expect(payload.count).to eq(3)
@@ -1516,38 +1516,38 @@ describe WampClient::Message do
1516
1516
 
1517
1517
  end
1518
1518
 
1519
- describe WampClient::Message::Challenge do
1519
+ describe Wamp::Client::Message::Challenge do
1520
1520
 
1521
1521
  it 'creates the message object' do
1522
1522
  params = ['string',{ test: 1 }]
1523
- object = WampClient::Message::Challenge.new(*params)
1523
+ object = Wamp::Client::Message::Challenge.new(*params)
1524
1524
 
1525
1525
  expect(object.authmethod).to eq('string')
1526
1526
  expect(object.extra).to eq({ test: 1 })
1527
- expect(object.is_a?(WampClient::Message::Challenge)).to eq(true)
1527
+ expect(object.is_a?(Wamp::Client::Message::Challenge)).to eq(true)
1528
1528
  end
1529
1529
 
1530
1530
  it 'parses the message and creates an object' do
1531
1531
  params = [4,'string',{ test: 1 }]
1532
- object = WampClient::Message::Challenge.parse(params)
1532
+ object = Wamp::Client::Message::Challenge.parse(params)
1533
1533
 
1534
1534
  expect(object.authmethod).to eq('string')
1535
1535
  expect(object.extra).to eq({ test: 1 })
1536
- expect(object.is_a?(WampClient::Message::Challenge)).to eq(true)
1536
+ expect(object.is_a?(Wamp::Client::Message::Challenge)).to eq(true)
1537
1537
  end
1538
1538
 
1539
1539
  it 'globally parses the message and creates an object' do
1540
1540
  params = [4,'string',{ test: 1 }]
1541
- object = WampClient::Message::Base.parse(params)
1541
+ object = Wamp::Client::Message::Base.parse(params)
1542
1542
 
1543
1543
  expect(object.authmethod).to eq('string')
1544
1544
  expect(object.extra).to eq({ test: 1 })
1545
- expect(object.is_a?(WampClient::Message::Challenge)).to eq(true)
1545
+ expect(object.is_a?(Wamp::Client::Message::Challenge)).to eq(true)
1546
1546
  end
1547
1547
 
1548
1548
  it 'generates the payload' do
1549
1549
  params = ['string',{ test: 1 }]
1550
- object = WampClient::Message::Challenge.new(*params)
1550
+ object = Wamp::Client::Message::Challenge.new(*params)
1551
1551
  payload = object.payload
1552
1552
 
1553
1553
  expect(payload.count).to eq(3)
@@ -1558,38 +1558,38 @@ describe WampClient::Message do
1558
1558
 
1559
1559
  end
1560
1560
 
1561
- describe WampClient::Message::Authenticate do
1561
+ describe Wamp::Client::Message::Authenticate do
1562
1562
 
1563
1563
  it 'creates the message object' do
1564
1564
  params = ['string',{ test: 1 }]
1565
- object = WampClient::Message::Authenticate.new(*params)
1565
+ object = Wamp::Client::Message::Authenticate.new(*params)
1566
1566
 
1567
1567
  expect(object.signature).to eq('string')
1568
1568
  expect(object.extra).to eq({ test: 1 })
1569
- expect(object.is_a?(WampClient::Message::Authenticate)).to eq(true)
1569
+ expect(object.is_a?(Wamp::Client::Message::Authenticate)).to eq(true)
1570
1570
  end
1571
1571
 
1572
1572
  it 'parses the message and creates an object' do
1573
1573
  params = [5,'string',{ test: 1 }]
1574
- object = WampClient::Message::Authenticate.parse(params)
1574
+ object = Wamp::Client::Message::Authenticate.parse(params)
1575
1575
 
1576
1576
  expect(object.signature).to eq('string')
1577
1577
  expect(object.extra).to eq({ test: 1 })
1578
- expect(object.is_a?(WampClient::Message::Authenticate)).to eq(true)
1578
+ expect(object.is_a?(Wamp::Client::Message::Authenticate)).to eq(true)
1579
1579
  end
1580
1580
 
1581
1581
  it 'globally parses the message and creates an object' do
1582
1582
  params = [5,'string',{ test: 1 }]
1583
- object = WampClient::Message::Base.parse(params)
1583
+ object = Wamp::Client::Message::Base.parse(params)
1584
1584
 
1585
1585
  expect(object.signature).to eq('string')
1586
1586
  expect(object.extra).to eq({ test: 1 })
1587
- expect(object.is_a?(WampClient::Message::Authenticate)).to eq(true)
1587
+ expect(object.is_a?(Wamp::Client::Message::Authenticate)).to eq(true)
1588
1588
  end
1589
1589
 
1590
1590
  it 'generates the payload' do
1591
1591
  params = ['string',{ test: 1 }]
1592
- object = WampClient::Message::Authenticate.new(*params)
1592
+ object = Wamp::Client::Message::Authenticate.new(*params)
1593
1593
  payload = object.payload
1594
1594
 
1595
1595
  expect(payload.count).to eq(3)
@@ -1600,38 +1600,38 @@ describe WampClient::Message do
1600
1600
 
1601
1601
  end
1602
1602
 
1603
- describe WampClient::Message::Cancel do
1603
+ describe Wamp::Client::Message::Cancel do
1604
1604
 
1605
1605
  it 'creates the message object' do
1606
1606
  params = [123,{ test: 1 }]
1607
- object = WampClient::Message::Cancel.new(*params)
1607
+ object = Wamp::Client::Message::Cancel.new(*params)
1608
1608
 
1609
1609
  expect(object.call_request).to eq(123)
1610
1610
  expect(object.options).to eq({ test: 1 })
1611
- expect(object.is_a?(WampClient::Message::Cancel)).to eq(true)
1611
+ expect(object.is_a?(Wamp::Client::Message::Cancel)).to eq(true)
1612
1612
  end
1613
1613
 
1614
1614
  it 'parses the message and creates an object' do
1615
1615
  params = [49,123,{ test: 1 }]
1616
- object = WampClient::Message::Cancel.parse(params)
1616
+ object = Wamp::Client::Message::Cancel.parse(params)
1617
1617
 
1618
1618
  expect(object.call_request).to eq(123)
1619
1619
  expect(object.options).to eq({ test: 1 })
1620
- expect(object.is_a?(WampClient::Message::Cancel)).to eq(true)
1620
+ expect(object.is_a?(Wamp::Client::Message::Cancel)).to eq(true)
1621
1621
  end
1622
1622
 
1623
1623
  it 'globally parses the message and creates an object' do
1624
1624
  params = [49,123,{ test: 1 }]
1625
- object = WampClient::Message::Base.parse(params)
1625
+ object = Wamp::Client::Message::Base.parse(params)
1626
1626
 
1627
1627
  expect(object.call_request).to eq(123)
1628
1628
  expect(object.options).to eq({ test: 1 })
1629
- expect(object.is_a?(WampClient::Message::Cancel)).to eq(true)
1629
+ expect(object.is_a?(Wamp::Client::Message::Cancel)).to eq(true)
1630
1630
  end
1631
1631
 
1632
1632
  it 'generates the payload' do
1633
1633
  params = [123,{ test: 1 }]
1634
- object = WampClient::Message::Cancel.new(*params)
1634
+ object = Wamp::Client::Message::Cancel.new(*params)
1635
1635
  payload = object.payload
1636
1636
 
1637
1637
  expect(payload.count).to eq(3)
@@ -1642,38 +1642,38 @@ describe WampClient::Message do
1642
1642
 
1643
1643
  end
1644
1644
 
1645
- describe WampClient::Message::Interrupt do
1645
+ describe Wamp::Client::Message::Interrupt do
1646
1646
 
1647
1647
  it 'creates the message object' do
1648
1648
  params = [123,{ test: 1 }]
1649
- object = WampClient::Message::Interrupt.new(*params)
1649
+ object = Wamp::Client::Message::Interrupt.new(*params)
1650
1650
 
1651
1651
  expect(object.invocation_request).to eq(123)
1652
1652
  expect(object.options).to eq({ test: 1 })
1653
- expect(object.is_a?(WampClient::Message::Interrupt)).to eq(true)
1653
+ expect(object.is_a?(Wamp::Client::Message::Interrupt)).to eq(true)
1654
1654
  end
1655
1655
 
1656
1656
  it 'parses the message and creates an object' do
1657
1657
  params = [69,123,{ test: 1 }]
1658
- object = WampClient::Message::Interrupt.parse(params)
1658
+ object = Wamp::Client::Message::Interrupt.parse(params)
1659
1659
 
1660
1660
  expect(object.invocation_request).to eq(123)
1661
1661
  expect(object.options).to eq({ test: 1 })
1662
- expect(object.is_a?(WampClient::Message::Interrupt)).to eq(true)
1662
+ expect(object.is_a?(Wamp::Client::Message::Interrupt)).to eq(true)
1663
1663
  end
1664
1664
 
1665
1665
  it 'globally parses the message and creates an object' do
1666
1666
  params = [69,123,{ test: 1 }]
1667
- object = WampClient::Message::Base.parse(params)
1667
+ object = Wamp::Client::Message::Base.parse(params)
1668
1668
 
1669
1669
  expect(object.invocation_request).to eq(123)
1670
1670
  expect(object.options).to eq({ test: 1 })
1671
- expect(object.is_a?(WampClient::Message::Interrupt)).to eq(true)
1671
+ expect(object.is_a?(Wamp::Client::Message::Interrupt)).to eq(true)
1672
1672
  end
1673
1673
 
1674
1674
  it 'generates the payload' do
1675
1675
  params = [123,{ test: 1 }]
1676
- object = WampClient::Message::Interrupt.new(*params)
1676
+ object = Wamp::Client::Message::Interrupt.new(*params)
1677
1677
  payload = object.payload
1678
1678
 
1679
1679
  expect(payload.count).to eq(3)