datawire_mdk 2.0.5

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.
@@ -0,0 +1,84 @@
1
+ # Quark 1.0.406 run at 2016-08-31 13:21:53.028839
2
+ module Quark
3
+ def self.quark; Quark; end
4
+ module Quark
5
+ def self.error; Error; end
6
+ module Error
7
+ require "datawire-quark-core"
8
+ require_relative 'reflect' # 1 () ()
9
+ require_relative '../datawire_mdk_md' # 0 () ('quark',)
10
+
11
+
12
+ def self.Error; Error; end
13
+ class Error < ::DatawireQuarkCore::QuarkObject
14
+ attr_accessor :message
15
+ extend ::DatawireQuarkCore::Static
16
+
17
+ static quark_error_Error_ref: -> { nil }
18
+
19
+
20
+
21
+ def initialize(message)
22
+
23
+ self.__init_fields__
24
+ (self).message = message
25
+
26
+ nil
27
+ end
28
+
29
+
30
+
31
+
32
+ def getMessage()
33
+
34
+ return @message
35
+
36
+ nil
37
+ end
38
+
39
+ def toString()
40
+
41
+ return (("Error(") + ((self).message)) + (")")
42
+
43
+ nil
44
+ end
45
+
46
+ def _getClass()
47
+
48
+ return "quark.error.Error"
49
+
50
+ nil
51
+ end
52
+
53
+ def _getField(name)
54
+
55
+ if ((name) == ("message"))
56
+ return (self).message
57
+ end
58
+ return nil
59
+
60
+ nil
61
+ end
62
+
63
+ def _setField(name, value)
64
+
65
+ if ((name) == ("message"))
66
+ (self).message = ::DatawireQuarkCore.cast(value) { ::String }
67
+ end
68
+
69
+ nil
70
+ end
71
+
72
+ def __init_fields__()
73
+
74
+ self.message = nil
75
+
76
+ nil
77
+ end
78
+
79
+
80
+ end
81
+ Error.unlazy_statics
82
+ end # module Error
83
+ end # module Quark
84
+ end # module Quark
@@ -0,0 +1,278 @@
1
+ # Quark 1.0.406 run at 2016-08-31 13:21:53.028839
2
+ module Quark
3
+ def self.quark; Quark; end
4
+ module Quark
5
+ def self.logging; Logging; end
6
+ module Logging
7
+ require "datawire-quark-core"
8
+ require_relative 'reflect' # 1 () ()
9
+ require_relative '../datawire_mdk_md' # 0 () ('quark',)
10
+
11
+
12
+ def self.Appender; Appender; end
13
+ ##
14
+ # Destination for logging
15
+
16
+ class Appender < ::DatawireQuarkCore::QuarkObject
17
+ attr_accessor :name
18
+ extend ::DatawireQuarkCore::Static
19
+
20
+ static quark_logging_Appender_ref: -> { nil }
21
+
22
+
23
+
24
+ def initialize(name)
25
+
26
+ self.__init_fields__
27
+ (self).name = name
28
+
29
+ nil
30
+ end
31
+
32
+
33
+
34
+
35
+ def _getClass()
36
+
37
+ return "quark.logging.Appender"
38
+
39
+ nil
40
+ end
41
+
42
+ def _getField(name)
43
+
44
+ if ((name) == ("name"))
45
+ return (self).name
46
+ end
47
+ return nil
48
+
49
+ nil
50
+ end
51
+
52
+ def _setField(name, value)
53
+
54
+ if ((name) == ("name"))
55
+ (self).name = ::DatawireQuarkCore.cast(value) { ::String }
56
+ end
57
+
58
+ nil
59
+ end
60
+
61
+ def __init_fields__()
62
+
63
+ self.name = nil
64
+
65
+ nil
66
+ end
67
+
68
+
69
+ end
70
+ Appender.unlazy_statics
71
+
72
+ ##
73
+ # Logging appender that sends log messages to standard output
74
+
75
+ def self.stdout()
76
+
77
+ return ::Quark.quark.logging.Appender.new(":STDOUT")
78
+
79
+
80
+ nil
81
+ end
82
+
83
+ ##
84
+ # Logging appender that sends log messages to standard error
85
+
86
+ def self.stderr()
87
+
88
+ return ::Quark.quark.logging.Appender.new(":STDERR")
89
+
90
+
91
+ nil
92
+ end
93
+
94
+ ##
95
+ # Logging appender that sends log messages to a file
96
+
97
+ def self.file(path)
98
+
99
+ return ::Quark.quark.logging.Appender.new(path)
100
+
101
+
102
+ nil
103
+ end
104
+
105
+ ##
106
+ # Set an environment variable to override logging set up in the code
107
+
108
+ def self.setEnvironmentOverride(envVar, level)
109
+
110
+ ::Quark.quark.logging.Config._overrideEnvVar = envVar
111
+ ::Quark.quark.logging.Config._overrideLevel = level
112
+
113
+
114
+ nil
115
+ end
116
+
117
+ def self.Config; Config; end
118
+ ##
119
+ # Logging configurator
120
+
121
+ class Config < ::DatawireQuarkCore::QuarkObject
122
+ attr_accessor :appender, :level
123
+ extend ::DatawireQuarkCore::Static
124
+
125
+ static _overrideEnvVar: -> { "QUARK_TRACE" }
126
+ static _overrideLevel: -> { "DEBUG" }
127
+ static _configured: -> { false }
128
+ static quark_logging_Config_ref: -> { nil }
129
+
130
+
131
+
132
+ def initialize()
133
+ self.__init_fields__
134
+
135
+ nil
136
+ end
137
+
138
+
139
+
140
+
141
+ ##
142
+ # Set the destination for logging, default stderr()
143
+
144
+ def setAppender(appender)
145
+
146
+ (self).appender = appender
147
+ return self
148
+
149
+ nil
150
+ end
151
+
152
+ ##
153
+ # set the logging level [trace|debug|info|warn|error], default 'info'
154
+
155
+ def setLevel(level)
156
+
157
+ (self).level = level
158
+ return self
159
+
160
+ nil
161
+ end
162
+
163
+ def self._getOverrideIfExists()
164
+
165
+ if ((::Quark.quark.logging.Config._overrideEnvVar) == (nil))
166
+ return ::DatawireQuarkCore.cast(nil) { ::String }
167
+ end
168
+ envVarValue = ENV[::Quark.quark.logging.Config._overrideEnvVar]
169
+ if (((((envVarValue) == (nil)) || ((envVarValue) == (""))) || ((envVarValue) == ("0"))) || (((envVarValue).downcase) == ("false")))
170
+ return ::DatawireQuarkCore.cast(nil) { ::String }
171
+ end
172
+ return envVarValue
173
+
174
+ nil
175
+ end
176
+
177
+ def self._autoconfig()
178
+
179
+ return (!(::Quark.quark.logging.Config._configured)) && ((::Quark.quark.logging.Config._getOverrideIfExists()) != (nil))
180
+
181
+ nil
182
+ end
183
+
184
+ ##
185
+ # Configure the logging
186
+
187
+ def configure()
188
+
189
+ envVarValue = ::Quark.quark.logging.Config._getOverrideIfExists()
190
+ if ((envVarValue) != (nil))
191
+ if (((envVarValue) == ("1")) || (((envVarValue).downcase) == ("true")))
192
+ @appender = ::Quark.quark.logging.stderr()
193
+ else
194
+ @appender = ::Quark.quark.logging.file(envVarValue)
195
+ end
196
+ @level = ::Quark.quark.logging.Config._overrideLevel
197
+ end
198
+ ::DatawireQuarkCore.configureLogging((@appender), (@level))
199
+ ::Quark.quark.logging.Config._configured = true
200
+
201
+ nil
202
+ end
203
+
204
+ def _getClass()
205
+
206
+ return "quark.logging.Config"
207
+
208
+ nil
209
+ end
210
+
211
+ def _getField(name)
212
+
213
+ if ((name) == ("_overrideEnvVar"))
214
+ return ::Quark.quark.logging.Config._overrideEnvVar
215
+ end
216
+ if ((name) == ("_overrideLevel"))
217
+ return ::Quark.quark.logging.Config._overrideLevel
218
+ end
219
+ if ((name) == ("_configured"))
220
+ return ::Quark.quark.logging.Config._configured
221
+ end
222
+ if ((name) == ("appender"))
223
+ return (self).appender
224
+ end
225
+ if ((name) == ("level"))
226
+ return (self).level
227
+ end
228
+ return nil
229
+
230
+ nil
231
+ end
232
+
233
+ def _setField(name, value)
234
+
235
+ if ((name) == ("_overrideEnvVar"))
236
+ ::Quark.quark.logging.Config._overrideEnvVar = ::DatawireQuarkCore.cast(value) { ::String }
237
+ end
238
+ if ((name) == ("_overrideLevel"))
239
+ ::Quark.quark.logging.Config._overrideLevel = ::DatawireQuarkCore.cast(value) { ::String }
240
+ end
241
+ if ((name) == ("_configured"))
242
+ ::Quark.quark.logging.Config._configured = ::DatawireQuarkCore.cast(value) { ::Object }
243
+ end
244
+ if ((name) == ("appender"))
245
+ (self).appender = ::DatawireQuarkCore.cast(value) { ::Quark.quark.logging.Appender }
246
+ end
247
+ if ((name) == ("level"))
248
+ (self).level = ::DatawireQuarkCore.cast(value) { ::String }
249
+ end
250
+
251
+ nil
252
+ end
253
+
254
+ def __init_fields__()
255
+
256
+ self.appender = ::Quark.quark.logging.stderr()
257
+ self.level = "INFO"
258
+
259
+ nil
260
+ end
261
+
262
+
263
+ end
264
+ Config.unlazy_statics
265
+
266
+ ##
267
+ # Create a logging configurator
268
+
269
+ def self.makeConfig()
270
+
271
+ return ::Quark.quark.logging.Config.new()
272
+
273
+
274
+ nil
275
+ end
276
+ end # module Logging
277
+ end # module Quark
278
+ end # module Quark
data/lib/quark/mock.rb ADDED
@@ -0,0 +1,1223 @@
1
+ # Quark 1.0.406 run at 2016-08-31 13:21:53.028839
2
+ module Quark
3
+ def self.quark; Quark; end
4
+ module Quark
5
+ def self.mock; Mock; end
6
+ module Mock
7
+ require "datawire-quark-core"
8
+ require_relative 'reflect' # 1 () ()
9
+ require_relative '../datawire_mdk_md' # 0 () ('quark',)
10
+ require_relative '../quark' # 0 () ('quark',)
11
+ require_relative 'concurrent' # 1 () ()
12
+ require_relative 'test' # 1 () ()
13
+
14
+
15
+ def self.MockEvent; MockEvent; end
16
+ class MockEvent < ::DatawireQuarkCore::QuarkObject
17
+ extend ::DatawireQuarkCore::Static
18
+
19
+ static quark_mock_MockEvent_ref: -> { nil }
20
+
21
+
22
+
23
+ def initialize()
24
+ self.__init_fields__
25
+
26
+ nil
27
+ end
28
+
29
+
30
+
31
+
32
+ def getType()
33
+ raise NotImplementedError, '`MockEvent.getType` is an abstract method'
34
+
35
+ nil
36
+ end
37
+
38
+ def getArgs()
39
+ raise NotImplementedError, '`MockEvent.getArgs` is an abstract method'
40
+
41
+ nil
42
+ end
43
+
44
+ def toString()
45
+
46
+ return (self.getType()) + ((self.getArgs()).to_s)
47
+
48
+ nil
49
+ end
50
+
51
+ def _getClass()
52
+
53
+ return "quark.mock.MockEvent"
54
+
55
+ nil
56
+ end
57
+
58
+ def _getField(name)
59
+
60
+ return nil
61
+
62
+ nil
63
+ end
64
+
65
+ def _setField(name, value)
66
+
67
+ nil
68
+
69
+ nil
70
+ end
71
+
72
+ def __init_fields__()
73
+
74
+
75
+ nil
76
+ end
77
+
78
+
79
+ end
80
+ MockEvent.unlazy_statics
81
+
82
+ def self.SocketEvent; SocketEvent; end
83
+ class SocketEvent < ::Quark.quark.mock.MockEvent
84
+ attr_accessor :url, :handler, :sock, :expectIdx
85
+ extend ::DatawireQuarkCore::Static
86
+
87
+ static quark_mock_SocketEvent_ref: -> { nil }
88
+
89
+
90
+
91
+ def initialize(url, handler)
92
+
93
+ super()
94
+ (self).url = url
95
+ (self).handler = handler
96
+
97
+ nil
98
+ end
99
+
100
+
101
+
102
+
103
+ def getType()
104
+
105
+ return "socket"
106
+
107
+ nil
108
+ end
109
+
110
+ def getArgs()
111
+
112
+ return ::DatawireQuarkCore::List.new([@url, @handler])
113
+
114
+ nil
115
+ end
116
+
117
+ def accept()
118
+
119
+ if ((@sock) != (nil))
120
+ ::Quark.quark.concurrent.Context.runtime().fail("already accepted")
121
+ else
122
+ @sock = ::Quark.quark.mock.MockSocket.new(@handler)
123
+ end
124
+
125
+ nil
126
+ end
127
+
128
+ def send(message)
129
+
130
+ @handler.onWSMessage(@sock, message)
131
+
132
+ nil
133
+ end
134
+
135
+ def close()
136
+
137
+ (self).sock.close()
138
+
139
+ nil
140
+ end
141
+
142
+ def expectMessage()
143
+
144
+ if ((@sock) == (nil))
145
+ ::Quark.quark.concurrent.Context.runtime().fail("not accepted")
146
+ end
147
+ if (::Quark.quark.test.check((@expectIdx) < (((@sock).messages).size), "expected a message"))
148
+ msg = ((@sock).messages)[@expectIdx]
149
+ @expectIdx = (@expectIdx) + (1)
150
+ return msg
151
+ end
152
+ return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.MockMessage }
153
+
154
+ nil
155
+ end
156
+
157
+ def expectTextMessage()
158
+
159
+ msg = self.expectMessage()
160
+ if (((msg) != (nil)) && (msg.isText()))
161
+ return ::DatawireQuarkCore.cast(msg) { ::Quark.quark.mock.TextMessage }
162
+ else
163
+ return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.TextMessage }
164
+ end
165
+
166
+ nil
167
+ end
168
+
169
+ def expectBinaryMessage()
170
+
171
+ msg = self.expectMessage()
172
+ if (((msg) != (nil)) && (msg.isBinary()))
173
+ return ::DatawireQuarkCore.cast(msg) { ::Quark.quark.mock.BinaryMessage }
174
+ else
175
+ return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.BinaryMessage }
176
+ end
177
+
178
+ nil
179
+ end
180
+
181
+ def _getClass()
182
+
183
+ return "quark.mock.SocketEvent"
184
+
185
+ nil
186
+ end
187
+
188
+ def _getField(name)
189
+
190
+ if ((name) == ("url"))
191
+ return (self).url
192
+ end
193
+ if ((name) == ("handler"))
194
+ return (self).handler
195
+ end
196
+ if ((name) == ("sock"))
197
+ return (self).sock
198
+ end
199
+ if ((name) == ("expectIdx"))
200
+ return (self).expectIdx
201
+ end
202
+ return nil
203
+
204
+ nil
205
+ end
206
+
207
+ def _setField(name, value)
208
+
209
+ if ((name) == ("url"))
210
+ (self).url = ::DatawireQuarkCore.cast(value) { ::String }
211
+ end
212
+ if ((name) == ("handler"))
213
+ (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.WSHandler }
214
+ end
215
+ if ((name) == ("sock"))
216
+ (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.quark.mock.MockSocket }
217
+ end
218
+ if ((name) == ("expectIdx"))
219
+ (self).expectIdx = ::DatawireQuarkCore.cast(value) { ::Integer }
220
+ end
221
+
222
+ nil
223
+ end
224
+
225
+ def __init_fields__()
226
+
227
+ super
228
+ self.url = nil
229
+ self.handler = nil
230
+ self.sock = nil
231
+ self.expectIdx = 0
232
+
233
+ nil
234
+ end
235
+
236
+
237
+ end
238
+ SocketEvent.unlazy_statics
239
+
240
+ def self.MockMessage; MockMessage; end
241
+ class MockMessage < ::DatawireQuarkCore::QuarkObject
242
+ extend ::DatawireQuarkCore::Static
243
+
244
+ static quark_mock_MockMessage_ref: -> { nil }
245
+
246
+
247
+
248
+ def initialize()
249
+ self.__init_fields__
250
+
251
+ nil
252
+ end
253
+
254
+
255
+
256
+
257
+ def isBinary()
258
+
259
+ return !(self.isText())
260
+
261
+ nil
262
+ end
263
+
264
+ def isText()
265
+ raise NotImplementedError, '`MockMessage.isText` is an abstract method'
266
+
267
+ nil
268
+ end
269
+
270
+ def _getClass()
271
+
272
+ return "quark.mock.MockMessage"
273
+
274
+ nil
275
+ end
276
+
277
+ def _getField(name)
278
+
279
+ return nil
280
+
281
+ nil
282
+ end
283
+
284
+ def _setField(name, value)
285
+
286
+ nil
287
+
288
+ nil
289
+ end
290
+
291
+ def __init_fields__()
292
+
293
+
294
+ nil
295
+ end
296
+
297
+
298
+ end
299
+ MockMessage.unlazy_statics
300
+
301
+ def self.TextMessage; TextMessage; end
302
+ ##
303
+ # A text message.
304
+
305
+ class TextMessage < ::Quark.quark.mock.MockMessage
306
+ attr_accessor :text
307
+ extend ::DatawireQuarkCore::Static
308
+
309
+ static quark_mock_TextMessage_ref: -> { nil }
310
+
311
+
312
+
313
+ def initialize(message)
314
+
315
+ super()
316
+ @text = message
317
+
318
+ nil
319
+ end
320
+
321
+
322
+
323
+
324
+ def isText()
325
+
326
+ return true
327
+
328
+ nil
329
+ end
330
+
331
+ def _getClass()
332
+
333
+ return "quark.mock.TextMessage"
334
+
335
+ nil
336
+ end
337
+
338
+ def _getField(name)
339
+
340
+ if ((name) == ("text"))
341
+ return (self).text
342
+ end
343
+ return nil
344
+
345
+ nil
346
+ end
347
+
348
+ def _setField(name, value)
349
+
350
+ if ((name) == ("text"))
351
+ (self).text = ::DatawireQuarkCore.cast(value) { ::String }
352
+ end
353
+
354
+ nil
355
+ end
356
+
357
+ def __init_fields__()
358
+
359
+ super
360
+ self.text = nil
361
+
362
+ nil
363
+ end
364
+
365
+
366
+ end
367
+ TextMessage.unlazy_statics
368
+
369
+ def self.BinaryMessage; BinaryMessage; end
370
+ ##
371
+ # A binary message.
372
+
373
+ class BinaryMessage < ::Quark.quark.mock.MockMessage
374
+ attr_accessor :bytes
375
+ extend ::DatawireQuarkCore::Static
376
+
377
+ static quark_mock_BinaryMessage_ref: -> { nil }
378
+
379
+
380
+
381
+ def initialize(message)
382
+
383
+ super()
384
+ @bytes = message
385
+
386
+ nil
387
+ end
388
+
389
+
390
+
391
+
392
+ def isText()
393
+
394
+ return false
395
+
396
+ nil
397
+ end
398
+
399
+ def _getClass()
400
+
401
+ return "quark.mock.BinaryMessage"
402
+
403
+ nil
404
+ end
405
+
406
+ def _getField(name)
407
+
408
+ if ((name) == ("bytes"))
409
+ return (self).bytes
410
+ end
411
+ return nil
412
+
413
+ nil
414
+ end
415
+
416
+ def _setField(name, value)
417
+
418
+ if ((name) == ("bytes"))
419
+ (self).bytes = value
420
+ end
421
+
422
+ nil
423
+ end
424
+
425
+ def __init_fields__()
426
+
427
+ super
428
+ self.bytes = nil
429
+
430
+ nil
431
+ end
432
+
433
+
434
+ end
435
+ BinaryMessage.unlazy_statics
436
+
437
+ def self.MockSocket; MockSocket; end
438
+ class MockSocket < ::DatawireQuarkCore::QuarkObject
439
+ attr_accessor :messages, :closed, :handler
440
+ extend ::DatawireQuarkCore::Static
441
+
442
+ static quark_List_quark_mock_MockMessage__ref: -> { nil }
443
+ static quark_mock_MockSocket_ref: -> { nil }
444
+
445
+
446
+
447
+ def initialize(handler)
448
+
449
+ self.__init_fields__
450
+ (self).handler = handler
451
+ (self).closed = false
452
+ (self).messages = ::DatawireQuarkCore::List.new([])
453
+ handler.onWSInit(self)
454
+ handler.onWSConnected(self)
455
+
456
+ nil
457
+ end
458
+
459
+
460
+
461
+
462
+ def send(message)
463
+
464
+ (@messages) << (::Quark.quark.mock.TextMessage.new(message))
465
+ return true
466
+
467
+ nil
468
+ end
469
+
470
+ def sendBinary(bytes)
471
+
472
+ (@messages) << (::Quark.quark.mock.BinaryMessage.new(bytes))
473
+ return true
474
+
475
+ nil
476
+ end
477
+
478
+ def close()
479
+
480
+ if (@closed)
481
+ ::Quark.quark.concurrent.Context.runtime().fail("already closed")
482
+ else
483
+ @handler.onWSClosed(self)
484
+ @handler.onWSFinal(self)
485
+ @closed = true
486
+ end
487
+ return true
488
+
489
+ nil
490
+ end
491
+
492
+ def _getClass()
493
+
494
+ return "quark.mock.MockSocket"
495
+
496
+ nil
497
+ end
498
+
499
+ def _getField(name)
500
+
501
+ if ((name) == ("messages"))
502
+ return (self).messages
503
+ end
504
+ if ((name) == ("closed"))
505
+ return (self).closed
506
+ end
507
+ if ((name) == ("handler"))
508
+ return (self).handler
509
+ end
510
+ return nil
511
+
512
+ nil
513
+ end
514
+
515
+ def _setField(name, value)
516
+
517
+ if ((name) == ("messages"))
518
+ (self).messages = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
519
+ end
520
+ if ((name) == ("closed"))
521
+ (self).closed = ::DatawireQuarkCore.cast(value) { ::Object }
522
+ end
523
+ if ((name) == ("handler"))
524
+ (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.WSHandler }
525
+ end
526
+
527
+ nil
528
+ end
529
+
530
+ def __init_fields__()
531
+
532
+ self.messages = ::DatawireQuarkCore::List.new([])
533
+ self.closed = false
534
+ self.handler = nil
535
+
536
+ nil
537
+ end
538
+
539
+
540
+ end
541
+ MockSocket.unlazy_statics
542
+
543
+ def self.RequestEvent; RequestEvent; end
544
+ class RequestEvent < ::Quark.quark.mock.MockEvent
545
+ attr_accessor :request, :handler
546
+ extend ::DatawireQuarkCore::Static
547
+
548
+ static quark_mock_RequestEvent_ref: -> { nil }
549
+
550
+
551
+
552
+ def initialize(request, handler)
553
+
554
+ super()
555
+ (self).request = request
556
+ (self).handler = handler
557
+
558
+ nil
559
+ end
560
+
561
+
562
+
563
+
564
+ def getType()
565
+
566
+ return "request"
567
+
568
+ nil
569
+ end
570
+
571
+ def getArgs()
572
+
573
+ return ::DatawireQuarkCore::List.new([@request, @handler])
574
+
575
+ nil
576
+ end
577
+
578
+ def respond(code, headers, body)
579
+
580
+ response = ::Quark.quark.mock.MockResponse.new()
581
+ (response).code = code
582
+ (response).headers = headers
583
+ (response).body = body
584
+ @handler.onHTTPInit(@request)
585
+ @handler.onHTTPResponse(@request, response)
586
+ @handler.onHTTPFinal(@request)
587
+
588
+ nil
589
+ end
590
+
591
+ def fail(error)
592
+
593
+ @handler.onHTTPInit(@request)
594
+ @handler.onHTTPError(@request, error)
595
+ @handler.onHTTPFinal(@request)
596
+
597
+ nil
598
+ end
599
+
600
+ def _getClass()
601
+
602
+ return "quark.mock.RequestEvent"
603
+
604
+ nil
605
+ end
606
+
607
+ def _getField(name)
608
+
609
+ if ((name) == ("request"))
610
+ return (self).request
611
+ end
612
+ if ((name) == ("handler"))
613
+ return (self).handler
614
+ end
615
+ return nil
616
+
617
+ nil
618
+ end
619
+
620
+ def _setField(name, value)
621
+
622
+ if ((name) == ("request"))
623
+ (self).request = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPRequest }
624
+ end
625
+ if ((name) == ("handler"))
626
+ (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPHandler }
627
+ end
628
+
629
+ nil
630
+ end
631
+
632
+ def __init_fields__()
633
+
634
+ super
635
+ self.request = nil
636
+ self.handler = nil
637
+
638
+ nil
639
+ end
640
+
641
+
642
+ end
643
+ RequestEvent.unlazy_statics
644
+
645
+ def self.MockResponse; MockResponse; end
646
+ class MockResponse < ::DatawireQuarkCore::QuarkObject
647
+ attr_accessor :code, :body, :headers
648
+ extend ::DatawireQuarkCore::Static
649
+
650
+ static quark_mock_MockResponse_ref: -> { nil }
651
+
652
+
653
+
654
+ def initialize()
655
+ self.__init_fields__
656
+
657
+ nil
658
+ end
659
+
660
+
661
+
662
+
663
+ def getCode()
664
+
665
+ return @code
666
+
667
+ nil
668
+ end
669
+
670
+ def setCode(code)
671
+
672
+ (self).code = code
673
+
674
+ nil
675
+ end
676
+
677
+ def getBody()
678
+
679
+ return @body
680
+
681
+ nil
682
+ end
683
+
684
+ def setBody(body)
685
+
686
+ (self).body = body
687
+
688
+ nil
689
+ end
690
+
691
+ def setHeader(key, value)
692
+
693
+ (@headers)[key] = (value)
694
+
695
+ nil
696
+ end
697
+
698
+ def getHeader(key)
699
+
700
+ return (@headers)[key]
701
+
702
+ nil
703
+ end
704
+
705
+ def getHeaders()
706
+
707
+ return ::DatawireQuarkCore::List.new((@headers).keys)
708
+
709
+ nil
710
+ end
711
+
712
+ def _getClass()
713
+
714
+ return "quark.mock.MockResponse"
715
+
716
+ nil
717
+ end
718
+
719
+ def _getField(name)
720
+
721
+ if ((name) == ("code"))
722
+ return (self).code
723
+ end
724
+ if ((name) == ("body"))
725
+ return (self).body
726
+ end
727
+ if ((name) == ("headers"))
728
+ return (self).headers
729
+ end
730
+ return nil
731
+
732
+ nil
733
+ end
734
+
735
+ def _setField(name, value)
736
+
737
+ if ((name) == ("code"))
738
+ (self).code = ::DatawireQuarkCore.cast(value) { ::Integer }
739
+ end
740
+ if ((name) == ("body"))
741
+ (self).body = ::DatawireQuarkCore.cast(value) { ::String }
742
+ end
743
+ if ((name) == ("headers"))
744
+ (self).headers = ::DatawireQuarkCore.cast(value) { ::Hash }
745
+ end
746
+
747
+ nil
748
+ end
749
+
750
+ def __init_fields__()
751
+
752
+ self.code = nil
753
+ self.body = nil
754
+ self.headers = {}
755
+
756
+ nil
757
+ end
758
+
759
+
760
+ end
761
+ MockResponse.unlazy_statics
762
+
763
+ def self.MockTask; MockTask; end
764
+ class MockTask < ::DatawireQuarkCore::QuarkObject
765
+ attr_accessor :task, :delay, :_scheduledFor
766
+ extend ::DatawireQuarkCore::Static
767
+
768
+ static quark_mock_MockTask_ref: -> { nil }
769
+
770
+
771
+
772
+ def initialize(task, delay)
773
+
774
+ self.__init_fields__
775
+ (self).task = task
776
+ (self).delay = delay
777
+
778
+ nil
779
+ end
780
+
781
+
782
+
783
+
784
+ def _getClass()
785
+
786
+ return "quark.mock.MockTask"
787
+
788
+ nil
789
+ end
790
+
791
+ def _getField(name)
792
+
793
+ if ((name) == ("task"))
794
+ return (self).task
795
+ end
796
+ if ((name) == ("delay"))
797
+ return (self).delay
798
+ end
799
+ if ((name) == ("_scheduledFor"))
800
+ return (self)._scheduledFor
801
+ end
802
+ return nil
803
+
804
+ nil
805
+ end
806
+
807
+ def _setField(name, value)
808
+
809
+ if ((name) == ("task"))
810
+ (self).task = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Task }
811
+ end
812
+ if ((name) == ("delay"))
813
+ (self).delay = ::DatawireQuarkCore.cast(value) { ::Float }
814
+ end
815
+ if ((name) == ("_scheduledFor"))
816
+ (self)._scheduledFor = ::DatawireQuarkCore.cast(value) { ::Integer }
817
+ end
818
+
819
+ nil
820
+ end
821
+
822
+ def __init_fields__()
823
+
824
+ self.task = nil
825
+ self.delay = nil
826
+ self._scheduledFor = nil
827
+
828
+ nil
829
+ end
830
+
831
+
832
+ end
833
+ MockTask.unlazy_statics
834
+
835
+ def self.MockRuntime; MockRuntime; end
836
+ class MockRuntime < ::DatawireQuarkCore::QuarkObject
837
+ attr_accessor :runtime, :events, :tasks, :_executed_tasks, :executed, :_currentTime
838
+ extend ::DatawireQuarkCore::Static
839
+
840
+ static quark_List_quark_mock_MockEvent__ref: -> { nil }
841
+ static quark_List_quark_mock_MockTask__ref: -> { nil }
842
+ static quark_List_quark_bool__ref: -> { nil }
843
+ static quark_mock_MockRuntime_ref: -> { nil }
844
+
845
+
846
+
847
+ def initialize(runtime)
848
+
849
+ self.__init_fields__
850
+ (self).runtime = runtime
851
+
852
+ nil
853
+ end
854
+
855
+
856
+
857
+
858
+ ##
859
+ # Execute all currently scheduled tasks.
860
+
861
+ def pump()
862
+
863
+ size = (@tasks).size
864
+ idx = 0
865
+ while ((idx) < (size)) do
866
+ if ((@_executed_tasks)[idx])
867
+ idx = (idx) + (1)
868
+ next
869
+ end
870
+ wrapper = (@tasks)[idx]
871
+ next_ = ((@tasks)[idx]).task
872
+ if (((wrapper)._scheduledFor) <= (self.now()))
873
+ (@_executed_tasks)[idx] = (true)
874
+ next_.onExecute(self)
875
+ @executed = (@executed) + (1)
876
+ end
877
+ idx = (idx) + (1)
878
+ end
879
+
880
+ nil
881
+ end
882
+
883
+ def open(url, handler)
884
+
885
+ (@events) << (::Quark.quark.mock.SocketEvent.new(url, handler))
886
+
887
+ nil
888
+ end
889
+
890
+ def request(request, handler)
891
+
892
+ (@events) << (::Quark.quark.mock.RequestEvent.new(request, handler))
893
+
894
+ nil
895
+ end
896
+
897
+ def schedule(handler, delayInSeconds)
898
+
899
+ task = ::Quark.quark.mock.MockTask.new(handler, delayInSeconds)
900
+ (task)._scheduledFor = (self.now()) + (((1000.0) * (delayInSeconds)).round())
901
+ (@tasks) << (task)
902
+ (@_executed_tasks) << (false)
903
+
904
+ nil
905
+ end
906
+
907
+ def codec()
908
+
909
+ return @runtime.codec()
910
+
911
+ nil
912
+ end
913
+
914
+ def now()
915
+
916
+ return @_currentTime
917
+
918
+ nil
919
+ end
920
+
921
+ def advanceClock(ms)
922
+
923
+ @_currentTime = (@_currentTime) + (ms)
924
+
925
+ nil
926
+ end
927
+
928
+ def sleep(seconds)
929
+
930
+ @runtime.sleep(seconds)
931
+
932
+ nil
933
+ end
934
+
935
+ def uuid()
936
+
937
+ return @runtime.uuid()
938
+
939
+ nil
940
+ end
941
+
942
+ def serveHTTP(url, servlet)
943
+
944
+ @runtime.fail("Runtime.serveHTTP not yet supported by the MockRuntime")
945
+
946
+ nil
947
+ end
948
+
949
+ def serveWS(url, servlet)
950
+
951
+ @runtime.fail("Runtime.serveWS not yet supported by the MockRuntime")
952
+
953
+ nil
954
+ end
955
+
956
+ def respond(request, response)
957
+
958
+ @runtime.fail("Runtime.respond not yet supported by the MockRuntime")
959
+
960
+ nil
961
+ end
962
+
963
+ def fail(message)
964
+
965
+ @runtime.fail(message)
966
+
967
+ nil
968
+ end
969
+
970
+ def logger(topic)
971
+
972
+ return @runtime.logger(topic)
973
+
974
+ nil
975
+ end
976
+
977
+ def callSafely(callee, defaultResult)
978
+
979
+ return (callee).call(nil)
980
+
981
+ nil
982
+ end
983
+
984
+ def _getClass()
985
+
986
+ return "quark.mock.MockRuntime"
987
+
988
+ nil
989
+ end
990
+
991
+ def _getField(name)
992
+
993
+ if ((name) == ("runtime"))
994
+ return (self).runtime
995
+ end
996
+ if ((name) == ("events"))
997
+ return (self).events
998
+ end
999
+ if ((name) == ("tasks"))
1000
+ return (self).tasks
1001
+ end
1002
+ if ((name) == ("_executed_tasks"))
1003
+ return (self)._executed_tasks
1004
+ end
1005
+ if ((name) == ("executed"))
1006
+ return (self).executed
1007
+ end
1008
+ if ((name) == ("_currentTime"))
1009
+ return (self)._currentTime
1010
+ end
1011
+ return nil
1012
+
1013
+ nil
1014
+ end
1015
+
1016
+ def _setField(name, value)
1017
+
1018
+ if ((name) == ("runtime"))
1019
+ (self).runtime = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Runtime }
1020
+ end
1021
+ if ((name) == ("events"))
1022
+ (self).events = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
1023
+ end
1024
+ if ((name) == ("tasks"))
1025
+ (self).tasks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
1026
+ end
1027
+ if ((name) == ("_executed_tasks"))
1028
+ (self)._executed_tasks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
1029
+ end
1030
+ if ((name) == ("executed"))
1031
+ (self).executed = ::DatawireQuarkCore.cast(value) { ::Integer }
1032
+ end
1033
+ if ((name) == ("_currentTime"))
1034
+ (self)._currentTime = ::DatawireQuarkCore.cast(value) { ::Integer }
1035
+ end
1036
+
1037
+ nil
1038
+ end
1039
+
1040
+ def __init_fields__()
1041
+
1042
+ self.runtime = nil
1043
+ self.events = ::DatawireQuarkCore::List.new([])
1044
+ self.tasks = ::DatawireQuarkCore::List.new([])
1045
+ self._executed_tasks = ::DatawireQuarkCore::List.new([])
1046
+ self.executed = 0
1047
+ self._currentTime = 1000000
1048
+
1049
+ nil
1050
+ end
1051
+
1052
+
1053
+ end
1054
+ MockRuntime.unlazy_statics
1055
+
1056
+ def self.MockRuntimeTest; MockRuntimeTest; end
1057
+ class MockRuntimeTest < ::DatawireQuarkCore::QuarkObject
1058
+ attr_accessor :mock, :old, :expectIdx, :sockets
1059
+ extend ::DatawireQuarkCore::Static
1060
+
1061
+ static quark_Map_quark_String_quark_mock_SocketEvent__ref: -> { nil }
1062
+ static quark_mock_MockRuntimeTest_ref: -> { nil }
1063
+
1064
+
1065
+
1066
+ def initialize()
1067
+ self.__init_fields__
1068
+
1069
+ nil
1070
+ end
1071
+
1072
+
1073
+
1074
+
1075
+ def setup()
1076
+
1077
+ @old = ::Quark.quark.concurrent.Context.current()
1078
+ ctx = ::Quark.quark.concurrent.Context.new(::Quark.quark.concurrent.Context.current())
1079
+ @mock = ::Quark.quark.mock.MockRuntime.new((ctx)._runtime)
1080
+ (ctx)._runtime = @mock
1081
+ ::Quark.quark.concurrent.Context.swap(ctx)
1082
+ @expectIdx = 0
1083
+ @sockets = {}
1084
+
1085
+ nil
1086
+ end
1087
+
1088
+ def teardown()
1089
+
1090
+ ::Quark.quark.concurrent.Context.swap(@old)
1091
+
1092
+ nil
1093
+ end
1094
+
1095
+ ##
1096
+ # Execute any pending asynchronous tasks.
1097
+
1098
+ def pump()
1099
+
1100
+ @mock.pump()
1101
+
1102
+ nil
1103
+ end
1104
+
1105
+ def expectNone()
1106
+
1107
+ delta = (((@mock).events).size) - (@expectIdx)
1108
+ ::Quark.quark.test.check((delta) == (0), ("expected no events, got ") + ((delta).to_s))
1109
+ return delta
1110
+
1111
+ nil
1112
+ end
1113
+
1114
+ def expectEvent(expectedType)
1115
+
1116
+ result = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.MockEvent }
1117
+ if (::Quark.quark.test.check((((@mock).events).size) > (@expectIdx), (("expected ") + (expectedType)) + (" event, got no events")))
1118
+ type = ((@mock).events)[@expectIdx].getType()
1119
+ if (::Quark.quark.test.check((type) == (expectedType), ((("expected ") + (expectedType)) + (" event, got ")) + (type)))
1120
+ result = ((@mock).events)[@expectIdx]
1121
+ end
1122
+ end
1123
+ @expectIdx = (@expectIdx) + (1)
1124
+ return result
1125
+
1126
+ nil
1127
+ end
1128
+
1129
+ def expectRequest(expectedUrl)
1130
+
1131
+ rev = ::DatawireQuarkCore.cast(self.expectEvent("request")) { ::Quark.quark.mock.RequestEvent }
1132
+ if ((rev) != (nil))
1133
+ if ((expectedUrl) == (nil))
1134
+ return rev
1135
+ end
1136
+ url = (rev).request.getUrl()
1137
+ if (::Quark.quark.test.check((url) == (expectedUrl), (((("expected request event to url(") + (expectedUrl)) + ("), got url(")) + (url)) + (")")))
1138
+ return rev
1139
+ end
1140
+ end
1141
+ return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.RequestEvent }
1142
+
1143
+ nil
1144
+ end
1145
+
1146
+ def expectSocket(expectedUrl)
1147
+
1148
+ sev = ::DatawireQuarkCore.cast(self.expectEvent("socket")) { ::Quark.quark.mock.SocketEvent }
1149
+ if ((sev) != (nil))
1150
+ (@sockets)[(sev).url] = (sev)
1151
+ if ((expectedUrl) == (nil))
1152
+ return sev
1153
+ end
1154
+ url = (sev).url
1155
+ if (::Quark.quark.test.check((url) == (expectedUrl), (((("expected socket event to url(") + (expectedUrl)) + ("), got url(")) + (url)) + (")")))
1156
+ return sev
1157
+ end
1158
+ end
1159
+ return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.SocketEvent }
1160
+
1161
+ nil
1162
+ end
1163
+
1164
+ def _getClass()
1165
+
1166
+ return "quark.mock.MockRuntimeTest"
1167
+
1168
+ nil
1169
+ end
1170
+
1171
+ def _getField(name)
1172
+
1173
+ if ((name) == ("mock"))
1174
+ return (self).mock
1175
+ end
1176
+ if ((name) == ("old"))
1177
+ return (self).old
1178
+ end
1179
+ if ((name) == ("expectIdx"))
1180
+ return (self).expectIdx
1181
+ end
1182
+ if ((name) == ("sockets"))
1183
+ return (self).sockets
1184
+ end
1185
+ return nil
1186
+
1187
+ nil
1188
+ end
1189
+
1190
+ def _setField(name, value)
1191
+
1192
+ if ((name) == ("mock"))
1193
+ (self).mock = ::DatawireQuarkCore.cast(value) { ::Quark.quark.mock.MockRuntime }
1194
+ end
1195
+ if ((name) == ("old"))
1196
+ (self).old = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
1197
+ end
1198
+ if ((name) == ("expectIdx"))
1199
+ (self).expectIdx = ::DatawireQuarkCore.cast(value) { ::Integer }
1200
+ end
1201
+ if ((name) == ("sockets"))
1202
+ (self).sockets = ::DatawireQuarkCore.cast(value) { ::Hash }
1203
+ end
1204
+
1205
+ nil
1206
+ end
1207
+
1208
+ def __init_fields__()
1209
+
1210
+ self.mock = nil
1211
+ self.old = nil
1212
+ self.expectIdx = 0
1213
+ self.sockets = nil
1214
+
1215
+ nil
1216
+ end
1217
+
1218
+
1219
+ end
1220
+ MockRuntimeTest.unlazy_statics
1221
+ end # module Mock
1222
+ end # module Quark
1223
+ end # module Quark