jsonschema 1.0.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.
@@ -0,0 +1,802 @@
1
+ require 'test/unit'
2
+ require File.dirname(__FILE__) + '/../lib/jsonschema'
3
+
4
+ class JSONSchemaTest < Test::Unit::TestCase
5
+ def test_maximum
6
+ schema = {
7
+ "type" => "object",
8
+ "properties" => {
9
+ "prop01" => {
10
+ "type" => "number",
11
+ "maximum" => 10
12
+ },
13
+ "prop02" => {
14
+ "type" => "integer",
15
+ "maximum" => 20
16
+ }
17
+ }
18
+ }
19
+ data1 = {
20
+ "prop01"=> 5,
21
+ "prop02"=> 10
22
+ }
23
+ data2 = {
24
+ "prop01"=> 10,
25
+ "prop02"=> 20
26
+ }
27
+ data3 = {
28
+ "prop01"=> 11,
29
+ "prop02"=> 19
30
+ }
31
+ data4 = {
32
+ "prop01"=> 9,
33
+ "prop02"=> 21
34
+ }
35
+ assert_nothing_raised{
36
+ JSON::Schema.validate(data1, schema)
37
+ }
38
+ assert_nothing_raised{
39
+ JSON::Schema.validate(data2, schema)
40
+ }
41
+ assert_raise(JSON::Schema::ValueError){
42
+ JSON::Schema.validate(data3, schema)
43
+ }
44
+ assert_raise(JSON::Schema::ValueError){
45
+ JSON::Schema.validate(data4, schema)
46
+ }
47
+ end
48
+
49
+ def test_minimum
50
+ schema = {
51
+ "type" => "object",
52
+ "properties" => {
53
+ "prop01" => {
54
+ "type" => "number",
55
+ "minimum" => 10
56
+ },
57
+ "prop02" => {
58
+ "type" => "integer",
59
+ "minimum" => 20
60
+ }
61
+ }
62
+ }
63
+ data1 = {
64
+ "prop01"=> 21,
65
+ "prop02"=> 21
66
+ }
67
+ data2 = {
68
+ "prop01"=> 10,
69
+ "prop02"=> 20
70
+ }
71
+ data3 = {
72
+ "prop01"=> 9,
73
+ "prop02"=> 21
74
+ }
75
+ data4 = {
76
+ "prop01"=> 10,
77
+ "prop02"=> 19
78
+ }
79
+ assert_nothing_raised{
80
+ JSON::Schema.validate(data1, schema)
81
+ }
82
+ assert_nothing_raised{
83
+ JSON::Schema.validate(data2, schema)
84
+ }
85
+ assert_raise(JSON::Schema::ValueError){
86
+ JSON::Schema.validate(data3, schema)
87
+ }
88
+ assert_raise(JSON::Schema::ValueError){
89
+ JSON::Schema.validate(data4, schema)
90
+ }
91
+ end
92
+
93
+ def test_minItems
94
+ schema1 = {
95
+ "type" => "array",
96
+ "minItems" => 4
97
+ }
98
+ schema2 = {
99
+ "minItems" => 4
100
+ }
101
+ data1 = [1, 2, "3", 4.0]
102
+ data2 = [1, 2, "3", 4.0, 5.00]
103
+ data3 = "test"
104
+ data4 = [1, 2, "3"]
105
+ assert_nothing_raised{
106
+ JSON::Schema.validate(data1, schema1)
107
+ }
108
+ assert_nothing_raised{
109
+ JSON::Schema.validate(data2, schema1)
110
+ }
111
+ assert_nothing_raised{
112
+ JSON::Schema.validate(data3, schema2)
113
+ }
114
+ assert_nothing_raised{
115
+ JSON::Schema.validate(data2, schema2)
116
+ }
117
+ assert_raise(JSON::Schema::ValueError){
118
+ JSON::Schema.validate(data4, schema1)
119
+ }
120
+ assert_raise(JSON::Schema::ValueError){
121
+ JSON::Schema.validate(data4, schema2)
122
+ }
123
+ end
124
+
125
+ def test_maxItems
126
+ schema1 = {
127
+ "type" => "array",
128
+ "maxItems" => 4
129
+ }
130
+ schema2 = {
131
+ "maxItems" => 4
132
+ }
133
+ data1 = [1, 2, "3", 4.0]
134
+ data2 = [1, 2, "3"]
135
+ data3 = "test"
136
+ data4 = [1, 2, "3", 4.0, 5.00]
137
+ assert_nothing_raised{
138
+ JSON::Schema.validate(data1, schema1)
139
+ }
140
+ assert_nothing_raised{
141
+ JSON::Schema.validate(data2, schema1)
142
+ }
143
+ assert_nothing_raised{
144
+ JSON::Schema.validate(data3, schema2)
145
+ }
146
+ assert_nothing_raised{
147
+ JSON::Schema.validate(data2, schema2)
148
+ }
149
+ assert_raise(JSON::Schema::ValueError){
150
+ JSON::Schema.validate(data4, schema1)
151
+ }
152
+ assert_raise(JSON::Schema::ValueError){
153
+ JSON::Schema.validate(data4, schema2)
154
+ }
155
+ end
156
+
157
+ def test_minLength
158
+ schema = {
159
+ "minLength" => 4
160
+ }
161
+ data1 = "test"
162
+ data2 = "string"
163
+ data3 = 123
164
+ data4 = [1, 2, "3"]
165
+ data5 = "car"
166
+ assert_nothing_raised{
167
+ JSON::Schema.validate(data1, schema)
168
+ }
169
+ assert_nothing_raised{
170
+ JSON::Schema.validate(data2, schema)
171
+ }
172
+ assert_nothing_raised{
173
+ JSON::Schema.validate(data3, schema)
174
+ }
175
+ assert_nothing_raised{
176
+ JSON::Schema.validate(data4, schema)
177
+ }
178
+ assert_raise(JSON::Schema::ValueError){
179
+ JSON::Schema.validate(data5, schema)
180
+ }
181
+ end
182
+ def test_maxLength
183
+ schema = {
184
+ "maxLength" => 4
185
+ }
186
+ data1 = "test"
187
+ data2 = "car"
188
+ data3 = 12345
189
+ data4 = [1, 2, "3", 4, 5]
190
+ data5 = "string"
191
+ assert_nothing_raised{
192
+ JSON::Schema.validate(data1, schema)
193
+ }
194
+ assert_nothing_raised{
195
+ JSON::Schema.validate(data2, schema)
196
+ }
197
+ assert_nothing_raised{
198
+ JSON::Schema.validate(data3, schema)
199
+ }
200
+ assert_nothing_raised{
201
+ JSON::Schema.validate(data4, schema)
202
+ }
203
+ assert_raise(JSON::Schema::ValueError){
204
+ JSON::Schema.validate(data5, schema)
205
+ }
206
+ end
207
+
208
+ def test_maxDecimal
209
+ schema = {
210
+ "type" => "number",
211
+ "maxDecimal" => 3
212
+ }
213
+ data1 = 10.20
214
+ data2 = 10.204
215
+ data3 = 10
216
+ data4 = 10.04092
217
+ assert_nothing_raised{
218
+ JSON::Schema.validate(data1, schema)
219
+ }
220
+ assert_nothing_raised{
221
+ JSON::Schema.validate(data2, schema)
222
+ }
223
+ assert_nothing_raised{
224
+ JSON::Schema.validate(data3, schema)
225
+ }
226
+ assert_raise(JSON::Schema::ValueError){
227
+ JSON::Schema.validate(data4, schema)
228
+ }
229
+ end
230
+
231
+ def test_properties
232
+ schema = {
233
+ "type"=>"object",
234
+ "properties"=>{
235
+ "prop01"=>{
236
+ "type"=>"string",
237
+ },
238
+ "prop02"=>{
239
+ "type"=>"number",
240
+ "optional"=>true
241
+ },
242
+ "prop03"=>{
243
+ "type"=>"integer",
244
+ },
245
+ "prop04"=>{
246
+ "type"=>"boolean",
247
+ },
248
+ "prop05"=>{
249
+ "type"=>"object",
250
+ "optional"=>true,
251
+ "properties"=>{
252
+ "subprop01"=>{
253
+ "type"=>"string",
254
+ },
255
+ "subprop02"=>{
256
+ "type"=>"string",
257
+ "optional"=>false
258
+ }
259
+ }
260
+ }
261
+ }
262
+ }
263
+ data1 = {
264
+ "prop01"=>"test",
265
+ "prop02"=>1.20,
266
+ "prop03"=>1,
267
+ "prop04"=>true,
268
+ "prop05"=>{
269
+ "subprop01"=>"test",
270
+ "subprop02"=>"test2"
271
+ }
272
+ }
273
+ assert_nothing_raised{
274
+ JSON::Schema.validate(data1, schema)
275
+ }
276
+ data2 = {
277
+ "prop01"=>"test",
278
+ "prop02"=>1.20,
279
+ "prop03"=>1,
280
+ "prop04"=>true
281
+ }
282
+ assert_nothing_raised{
283
+ JSON::Schema.validate(data2, schema)
284
+ }
285
+ data3 = {
286
+ "prop02"=>1.60,
287
+ "prop05"=>{
288
+ "subprop01"=>"test"
289
+ }
290
+ }
291
+ assert_raise(JSON::Schema::ValueError){
292
+ JSON::Schema.validate(data3, schema)
293
+ }
294
+ end
295
+
296
+ def test_title
297
+ schema1 = {
298
+ "title"=>"My Title for My Schema"
299
+ }
300
+ schema2 = {
301
+ "title"=>1233
302
+ }
303
+ data = "whatever"
304
+ assert_nothing_raised{
305
+ JSON::Schema.validate(data, schema1)
306
+ }
307
+ assert_raise(JSON::Schema::ValueError){
308
+ JSON::Schema.validate(data, schema2)
309
+ }
310
+ end
311
+
312
+ def test_requires
313
+ schema = {
314
+ "type"=>"object",
315
+ "properties"=>{
316
+ "prop01"=>{
317
+ "type"=>"string",
318
+ "optional"=>true
319
+ },
320
+ "prop02"=>{
321
+ "type"=>"number",
322
+ "optional"=>true,
323
+ "requires"=>"prop01"
324
+ }
325
+ }
326
+ }
327
+ data1 = {}
328
+ data2 = {
329
+ "prop01"=>"test",
330
+ "prop02"=>2
331
+ }
332
+ assert_nothing_raised{
333
+ JSON::Schema.validate(data1, schema)
334
+ }
335
+ assert_nothing_raised{
336
+ JSON::Schema.validate(data2, schema)
337
+ }
338
+ data3 = {
339
+ "prop02"=>2
340
+ }
341
+ assert_raise(JSON::Schema::ValueError){
342
+ JSON::Schema.validate(data3, schema)
343
+ }
344
+ end
345
+
346
+ def test_pattern
347
+ schema = {
348
+ "pattern"=>"^[A-Za-z0-9][A-Za-z0-9\.]*@([A-Za-z0-9]+\.)+[A-Za-z0-9]+$"
349
+ }
350
+ data1 = "my.email01@gmail.com"
351
+ assert_nothing_raised{
352
+ JSON::Schema.validate(data1, schema)
353
+ }
354
+ data2 = 123
355
+ assert_nothing_raised{
356
+ JSON::Schema.validate(data2, schema)
357
+ }
358
+ data3 = "whatever"
359
+ assert_raise(JSON::Schema::ValueError){
360
+ JSON::Schema.validate(data3, schema)
361
+ }
362
+ end
363
+
364
+ def test_optional
365
+ schema = {
366
+ "type"=>"object",
367
+ "properties"=>{
368
+ "prop01"=>{
369
+ "type"=>"string"
370
+ },
371
+ "prop02"=>{
372
+ "type"=>"number",
373
+ "optional"=>true
374
+ },
375
+ "prop03"=>{
376
+ "type"=>"integer"
377
+ },
378
+ "prop04"=>{
379
+ "type"=>"boolean",
380
+ "optional"=>false
381
+ }
382
+ }
383
+ }
384
+ data1 = {
385
+ "prop01"=>"test",
386
+ "prop03"=>1,
387
+ "prop04"=>false
388
+ }
389
+ assert_nothing_raised{
390
+ JSON::Schema.validate(data1, schema)
391
+ }
392
+ data2 = {
393
+ "prop02"=>"blah"
394
+ }
395
+ assert_raise(JSON::Schema::ValueError){
396
+ JSON::Schema.validate(data2, schema)
397
+ }
398
+ end
399
+
400
+ def test_default
401
+ schema1 = {
402
+ "properties"=>{
403
+ "test"=>{
404
+ "optional"=>true,
405
+ "default"=>10
406
+ },
407
+ }
408
+ }
409
+ schema2 = {
410
+ "properties"=>{
411
+ "test"=>{
412
+ "optional"=>true,
413
+ "default"=>10,
414
+ "readonly"=>true
415
+ }
416
+ }
417
+ }
418
+ data1 = {}
419
+ assert_nothing_raised{
420
+ JSON::Schema.validate(data1, schema1)
421
+ }
422
+ assert_equal(10, data1["test"])
423
+
424
+ data2 = {}
425
+ assert_nothing_raised{
426
+ JSON::Schema.validate(data2, schema2)
427
+ }
428
+ assert_not_equal(10, data2["test"])
429
+
430
+ data3 = {}
431
+ assert_nothing_raised{
432
+ JSON::Schema.validate(data3, schema1, true)
433
+ }
434
+ assert_equal(10, data3["test"])
435
+
436
+ data4 = {}
437
+ assert_nothing_raised{
438
+ JSON::Schema.validate(data4, schema1, false)
439
+ }
440
+ assert_not_equal(10, data4["test"])
441
+ end
442
+
443
+ def test_description
444
+ schema1 = {
445
+ "description"=>"My Description for My Schema"
446
+ }
447
+ schema2 = {
448
+ "description"=>1233
449
+ }
450
+ data = "whatever"
451
+ assert_nothing_raised{
452
+ JSON::Schema.validate(data, schema1)
453
+ }
454
+ assert_raise(JSON::Schema::ValueError){
455
+ JSON::Schema.validate(data, schema2)
456
+ }
457
+ end
458
+
459
+ def test_type
460
+ # schema
461
+ schema1 = {
462
+ "type"=>[
463
+ {
464
+ "type"=>"array",
465
+ "minItems"=>10
466
+ },
467
+ {
468
+ "type"=>"string",
469
+ "pattern"=>"^0+$"
470
+ }
471
+ ]
472
+ }
473
+ data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
474
+ data2 = "0"
475
+ data3 = 1203
476
+ assert_nothing_raised{
477
+ JSON::Schema.validate(data1, schema1)
478
+ }
479
+ assert_nothing_raised{
480
+ JSON::Schema.validate(data2, schema1)
481
+ }
482
+ assert_raise(JSON::Schema::ValueError){
483
+ JSON::Schema.validate(data3, schema1)
484
+ }
485
+
486
+ # integer phase
487
+ [1, 89, 48, 32, 49, 42].each do |item|
488
+ assert_nothing_raised{
489
+ JSON::Schema.validate(item, {"type"=>"integer"})
490
+ }
491
+ end
492
+ [1.2, "bad", {"test" => "blah"}, [32, 49], nil, true].each do |item|
493
+ assert_raise(JSON::Schema::ValueError){
494
+ JSON::Schema.validate(item, {"type"=>"integer"})
495
+ }
496
+ end
497
+
498
+ # string phase
499
+ ["surrender?", "nuts!", "ok", "@hsuha", "\'ok?\'", "blah"].each do |item|
500
+ assert_nothing_raised{
501
+ JSON::Schema.validate(item, {"type"=>"string"})
502
+ }
503
+ end
504
+ [1.2, 1, {"test" => "blah"}, [32, 49], nil, true].each do |item|
505
+ assert_raise(JSON::Schema::ValueError){
506
+ JSON::Schema.validate(item, {"type"=>"string"})
507
+ }
508
+ end
509
+
510
+ # number phase
511
+ [1.2, 89.42, 48.5224242, 32, 49, 42.24324].each do |item|
512
+ assert_nothing_raised{
513
+ JSON::Schema.validate(item, {"type"=>"number"})
514
+ }
515
+ end
516
+ ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true].each do |item|
517
+ assert_raise(JSON::Schema::ValueError){
518
+ JSON::Schema.validate(item, {"type"=>"number"})
519
+ }
520
+ end
521
+
522
+ # boolean phase
523
+ [true, false].each do |item|
524
+ assert_nothing_raised{
525
+ JSON::Schema.validate(item, {"type"=>"boolean"})
526
+ }
527
+ end
528
+ [1.2, "False", {"test" => "blah"}, [32, 49], nil, 1, 0].each do |item|
529
+ assert_raise(JSON::Schema::ValueError){
530
+ JSON::Schema.validate(item, {"type"=>"boolean"})
531
+ }
532
+ end
533
+
534
+ # object phase
535
+ [{"blah"=>"test"}, {"this"=>{"blah"=>"test"}}, {1=>2, 10=>20}].each do |item|
536
+ assert_nothing_raised{
537
+ JSON::Schema.validate(item, {"type"=>"object"})
538
+ }
539
+ end
540
+ [1.2, "bad", 123, [32, 49], nil, true].each do |item|
541
+ assert_raise(JSON::Schema::ValueError){
542
+ JSON::Schema.validate(item, {"type"=>"object"})
543
+ }
544
+ end
545
+
546
+ # array phase
547
+ [[1, 89], [48, {"test"=>"blah"}, "49", 42]].each do |item|
548
+ assert_nothing_raised{
549
+ JSON::Schema.validate(item, {"type"=>"array"})
550
+ }
551
+ end
552
+ [1.2, "bad", {"test"=>"blah"}, 1234, nil, true].each do |item|
553
+ assert_raise(JSON::Schema::ValueError){
554
+ JSON::Schema.validate(item, {"type"=>"array"})
555
+ }
556
+ end
557
+
558
+ # null phase
559
+ assert_nothing_raised{
560
+ JSON::Schema.validate(nil, {"type"=>"null"})
561
+ }
562
+ [1.2, "bad", {"test"=>"blah"}, [32, 49], 1284, true].each do |item|
563
+ assert_raise(JSON::Schema::ValueError){
564
+ JSON::Schema.validate(item, {"type"=>"null"})
565
+ }
566
+ end
567
+
568
+ # any phase
569
+ [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, 1284, true].each do |item|
570
+ assert_nothing_raised{
571
+ JSON::Schema.validate(item, {"type"=>"any"})
572
+ }
573
+ end
574
+
575
+ end
576
+
577
+ def test_items
578
+ schema1 = {
579
+ "type"=>"array",
580
+ "items"=>{
581
+ "type"=>"string"
582
+ }
583
+ }
584
+ schema2 = {
585
+ "type"=>"array",
586
+ "items"=>[
587
+ {"type"=>"integer"},
588
+ {"type"=>"string"},
589
+ {"type"=>"boolean"}
590
+ ]
591
+ }
592
+ data1 = ["string", "another string", "mystring"]
593
+ data2 = ["JSON Schema is cool", "yet another string"]
594
+ assert_nothing_raised{
595
+ JSON::Schema.validate(data1, schema1)
596
+ }
597
+ assert_nothing_raised{
598
+ JSON::Schema.validate(data2, schema1)
599
+ }
600
+ data3 = ["string", "another string", 1]
601
+ assert_raise(JSON::Schema::ValueError){
602
+ JSON::Schema.validate(data3, schema1)
603
+ }
604
+ data4 = [1, "More strings?", true]
605
+ data5 = [12482, "Yes, more strings", false]
606
+ assert_nothing_raised{
607
+ JSON::Schema.validate(data4, schema2)
608
+ }
609
+ assert_nothing_raised{
610
+ JSON::Schema.validate(data5, schema2)
611
+ }
612
+ data6 = [1294, "Ok. I give up"]
613
+ assert_raise(JSON::Schema::ValueError){
614
+ JSON::Schema.validate(data6, schema2)
615
+ }
616
+ data7 = [1294, "Ok. I give up", "Not a boolean"]
617
+ assert_raise(JSON::Schema::ValueError){
618
+ JSON::Schema.validate(data7, schema2)
619
+ }
620
+ end
621
+
622
+ def test_enum
623
+ schema = {
624
+ "enum"=>["test", true, 123, ["???"]]
625
+ }
626
+ ["test", true, 123, ["???"]].each do |item|
627
+ assert_nothing_raised{
628
+ JSON::Schema.validate(item, schema)
629
+ }
630
+ end
631
+ assert_raise(JSON::Schema::ValueError){
632
+ JSON::Schema.validate("unknown", schema)
633
+ }
634
+ end
635
+
636
+
637
+ def test_additionalProperties
638
+ schema1 = {
639
+ "additionalProperties"=>{
640
+ "type" => "integer"
641
+ }
642
+ }
643
+ [1, 89, 48, 32, 49, 42].each do |item|
644
+ assert_nothing_raised{
645
+ JSON::Schema.validate({"prop" => item}, schema1)
646
+ }
647
+ end
648
+ [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, true].each do |item|
649
+ assert_raise(JSON::Schema::ValueError){
650
+ JSON::Schema.validate({"prop" => item}, schema1)
651
+ }
652
+ end
653
+ schema2 = {
654
+ "properties" => {
655
+ "prop1" => {"type" => "integer"},
656
+ "prop2" => {"type" => "string" }
657
+ },
658
+ "additionalProperties" => {
659
+ "type" => ["string", "number"]
660
+ }
661
+ }
662
+ [1, "test", 48, "ok", 4.9, 42].each do |item|
663
+ assert_nothing_raised{
664
+ JSON::Schema.validate({
665
+ "prop1" => 123,
666
+ "prop2" => "this is prop2",
667
+ "prop3" => item
668
+ }, schema2)
669
+ }
670
+ end
671
+ [{"test"=>"blah"}, [32, 49], nil, true].each do |item|
672
+ assert_raise(JSON::Schema::ValueError){
673
+ JSON::Schema.validate({
674
+ "prop1" => 123,
675
+ "prop2" => "this is prop2",
676
+ "prop3" => item
677
+ }, schema2)
678
+ }
679
+ end
680
+ schema3 = {
681
+ "additionalProperties" => true
682
+ }
683
+ [1.2, 1, {"test"=>"blah"}, [32, 49], nil, true, "blah"].each do |item|
684
+ assert_nothing_raised{
685
+ JSON::Schema.validate({"prop" => item}, schema3)
686
+ }
687
+ end
688
+ schema4 = {
689
+ "additionalProperties" => false
690
+ }
691
+ ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true, 1.34].each do |item|
692
+ assert_raise(JSON::Schema::ValueError){
693
+ JSON::Schema.validate({"prop" => item}, schema4)
694
+ }
695
+ end
696
+ end
697
+
698
+ def test_disallow
699
+ # multi phase
700
+ schema = {"disallow"=>["null","integer","string"]}
701
+ [nil, 183, "mystring"].each do |item|
702
+ assert_raise(JSON::Schema::ValueError){
703
+ JSON::Schema.validate(item, schema)
704
+ }
705
+ end
706
+ [1.2, {"test"=>"blah"}, [32, 49], true].each do |item|
707
+ assert_nothing_raised{
708
+ JSON::Schema.validate(item, schema)
709
+ }
710
+ end
711
+
712
+ # any phase
713
+ [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, 1284, true].each do |item|
714
+ assert_raise(JSON::Schema::ValueError){
715
+ JSON::Schema.validate(item, {"disallow"=>"any"})
716
+ }
717
+ end
718
+
719
+ # null phase
720
+ assert_raise(JSON::Schema::ValueError){
721
+ JSON::Schema.validate(nil, {"disallow"=>"null"})
722
+ }
723
+ [1.2, "bad", {"test"=>"blah"}, [32, 49], 1284, true].each do |item|
724
+ assert_nothing_raised{
725
+ JSON::Schema.validate(item, {"disallow"=>"null"})
726
+ }
727
+ end
728
+
729
+ # array phase
730
+ [[1, 89], [48, {"test"=>"blah"}, "49", 42]].each do |item|
731
+ assert_raise(JSON::Schema::ValueError){
732
+ JSON::Schema.validate(item, {"disallow"=>"array"})
733
+ }
734
+ end
735
+ [1.2, "bad", {"test"=>"blah"}, 1234, nil, true].each do |item|
736
+ assert_nothing_raised{
737
+ JSON::Schema.validate(item, {"disallow"=>"array"})
738
+ }
739
+ end
740
+
741
+ # object phase
742
+ [{"blah"=>"test"}, {"this"=>{"blah"=>"test"}}, {1=>2, 10=>20}].each do |item|
743
+ assert_raise(JSON::Schema::ValueError){
744
+ JSON::Schema.validate(item, {"disallow"=>"object"})
745
+ }
746
+ end
747
+ [1.2, "bad", 123, [32, 49], nil, true].each do |item|
748
+ assert_nothing_raised{
749
+ JSON::Schema.validate(item, {"disallow"=>"object"})
750
+ }
751
+ end
752
+
753
+ # boolean phase
754
+ [true, false].each do |item|
755
+ assert_raise(JSON::Schema::ValueError){
756
+ JSON::Schema.validate(item, {"disallow"=>"boolean"})
757
+ }
758
+ end
759
+ [1.2, "False", {"test" => "blah"}, [32, 49], nil, 1, 0].each do |item|
760
+ assert_nothing_raised{
761
+ JSON::Schema.validate(item, {"disallow"=>"boolean"})
762
+ }
763
+ end
764
+
765
+ # number phase
766
+ [1.2, 89.42, 48.5224242, 32, 49, 42.24324].each do |item|
767
+ assert_raise(JSON::Schema::ValueError){
768
+ JSON::Schema.validate(item, {"disallow"=>"number"})
769
+ }
770
+ end
771
+ ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true].each do |item|
772
+ assert_nothing_raised{
773
+ JSON::Schema.validate(item, {"disallow"=>"number"})
774
+ }
775
+ end
776
+
777
+ # integer phase
778
+ [1, 89, 48, 32, 49, 42].each do |item|
779
+ assert_raise(JSON::Schema::ValueError){
780
+ JSON::Schema.validate(item, {"disallow"=>"integer"})
781
+ }
782
+ end
783
+ [1.2, "bad", {"test" => "blah"}, [32, 49], nil, true].each do |item|
784
+ assert_nothing_raised{
785
+ JSON::Schema.validate(item, {"disallow"=>"integer"})
786
+ }
787
+ end
788
+
789
+ # string phase
790
+ ["surrender?", "nuts!", "ok", "@hsuha", "\'ok?\'", "blah"].each do |item|
791
+ assert_raise(JSON::Schema::ValueError){
792
+ JSON::Schema.validate(item, {"disallow"=>"string"})
793
+ }
794
+ end
795
+ [1.2, 1, {"test" => "blah"}, [32, 49], nil, true].each do |item|
796
+ assert_nothing_raised{
797
+ JSON::Schema.validate(item, {"disallow"=>"string"})
798
+ }
799
+ end
800
+ end
801
+ end
802
+