← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/Newtonsoft.Json/Src/Newtonsoft.Json.Tests/Schema/JsonSchemaGeneratorTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/Newtonsoft.Json/Src/Newtonsoft.Json.Tests/Schema/JsonSchemaGeneratorTests.cs
 
1
#region License
 
2
// Copyright (c) 2007 James Newton-King
 
3
//
 
4
// Permission is hereby granted, free of charge, to any person
 
5
// obtaining a copy of this software and associated documentation
 
6
// files (the "Software"), to deal in the Software without
 
7
// restriction, including without limitation the rights to use,
 
8
// copy, modify, merge, publish, distribute, sublicense, and/or sell
 
9
// copies of the Software, and to permit persons to whom the
 
10
// Software is furnished to do so, subject to the following
 
11
// conditions:
 
12
//
 
13
// The above copyright notice and this permission notice shall be
 
14
// included in all copies or substantial portions of the Software.
 
15
//
 
16
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
17
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 
18
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
19
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 
20
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 
21
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
22
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
23
// OTHER DEALINGS IN THE SOFTWARE.
 
24
#endregion
 
25
 
 
26
using System;
 
27
using System.Collections;
 
28
using System.Collections.Generic;
 
29
using System.Globalization;
 
30
using Newtonsoft.Json.Converters;
 
31
using Newtonsoft.Json.Serialization;
 
32
using Newtonsoft.Json.Tests.TestObjects;
 
33
using Newtonsoft.Json.Utilities;
 
34
#if !NETFX_CORE
 
35
using NUnit.Framework;
 
36
#else
 
37
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
38
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
39
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
40
#endif
 
41
using Newtonsoft.Json.Schema;
 
42
using System.IO;
 
43
using Newtonsoft.Json.Linq;
 
44
using System.Text;
 
45
using Extensions=Newtonsoft.Json.Schema.Extensions;
 
46
#if NET20
 
47
using Newtonsoft.Json.Utilities.LinqBridge;
 
48
#else
 
49
using System.Linq;
 
50
#endif
 
51
 
 
52
namespace Newtonsoft.Json.Tests.Schema
 
53
{
 
54
  [TestFixture]
 
55
  public class JsonSchemaGeneratorTests : TestFixtureBase
 
56
  {
 
57
    [Test]
 
58
    public void Generate_GenericDictionary()
 
59
    {
 
60
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
61
      JsonSchema schema = generator.Generate(typeof (Dictionary<string, List<string>>));
 
62
 
 
63
      string json = schema.ToString();
 
64
 
 
65
      Assert.AreEqual(@"{
 
66
  ""type"": ""object"",
 
67
  ""additionalProperties"": {
 
68
    ""type"": [
 
69
      ""array"",
 
70
      ""null""
 
71
    ],
 
72
    ""items"": {
 
73
      ""type"": [
 
74
        ""string"",
 
75
        ""null""
 
76
      ]
 
77
    }
 
78
  }
 
79
}", json);
 
80
 
 
81
      Dictionary<string, List<string>> value = new Dictionary<string, List<string>>
 
82
                                                 {
 
83
                                                   {"HasValue", new List<string>() { "first", "second", null }},
 
84
                                                   {"NoValue", null}
 
85
                                                 };
 
86
 
 
87
      string valueJson = JsonConvert.SerializeObject(value, Formatting.Indented);
 
88
      JObject o = JObject.Parse(valueJson);
 
89
 
 
90
      Assert.IsTrue(o.IsValid(schema));
 
91
    }
 
92
 
 
93
#if !(NETFX_CORE || PORTABLE)
 
94
    [Test]
 
95
    public void Generate_DefaultValueAttributeTestClass()
 
96
    {
 
97
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
98
      JsonSchema schema = generator.Generate(typeof(DefaultValueAttributeTestClass));
 
99
 
 
100
      string json = schema.ToString();
 
101
 
 
102
      Assert.AreEqual(@"{
 
103
  ""description"": ""DefaultValueAttributeTestClass description!"",
 
104
  ""type"": ""object"",
 
105
  ""additionalProperties"": false,
 
106
  ""properties"": {
 
107
    ""TestField1"": {
 
108
      ""required"": true,
 
109
      ""type"": ""integer"",
 
110
      ""default"": 21
 
111
    },
 
112
    ""TestProperty1"": {
 
113
      ""required"": true,
 
114
      ""type"": [
 
115
        ""string"",
 
116
        ""null""
 
117
      ],
 
118
      ""default"": ""TestProperty1Value""
 
119
    }
 
120
  }
 
121
}", json);
 
122
    }
 
123
#endif
 
124
 
 
125
    [Test]
 
126
    public void Generate_Person()
 
127
    {
 
128
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
129
      JsonSchema schema = generator.Generate(typeof(Person));
 
130
 
 
131
      string json = schema.ToString();
 
132
 
 
133
      Assert.AreEqual(@"{
 
134
  ""id"": ""Person"",
 
135
  ""title"": ""Title!"",
 
136
  ""description"": ""JsonObjectAttribute description!"",
 
137
  ""type"": ""object"",
 
138
  ""properties"": {
 
139
    ""Name"": {
 
140
      ""required"": true,
 
141
      ""type"": [
 
142
        ""string"",
 
143
        ""null""
 
144
      ]
 
145
    },
 
146
    ""BirthDate"": {
 
147
      ""required"": true,
 
148
      ""type"": ""string""
 
149
    },
 
150
    ""LastModified"": {
 
151
      ""required"": true,
 
152
      ""type"": ""string""
 
153
    }
 
154
  }
 
155
}", json);
 
156
    }
 
157
 
 
158
    [Test]
 
159
    public void Generate_UserNullable()
 
160
    {
 
161
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
162
      JsonSchema schema = generator.Generate(typeof(UserNullable));
 
163
 
 
164
      string json = schema.ToString();
 
165
 
 
166
      Assert.AreEqual(@"{
 
167
  ""type"": ""object"",
 
168
  ""properties"": {
 
169
    ""Id"": {
 
170
      ""required"": true,
 
171
      ""type"": ""string""
 
172
    },
 
173
    ""FName"": {
 
174
      ""required"": true,
 
175
      ""type"": [
 
176
        ""string"",
 
177
        ""null""
 
178
      ]
 
179
    },
 
180
    ""LName"": {
 
181
      ""required"": true,
 
182
      ""type"": [
 
183
        ""string"",
 
184
        ""null""
 
185
      ]
 
186
    },
 
187
    ""RoleId"": {
 
188
      ""required"": true,
 
189
      ""type"": ""integer""
 
190
    },
 
191
    ""NullableRoleId"": {
 
192
      ""required"": true,
 
193
      ""type"": [
 
194
        ""integer"",
 
195
        ""null""
 
196
      ]
 
197
    },
 
198
    ""NullRoleId"": {
 
199
      ""required"": true,
 
200
      ""type"": [
 
201
        ""integer"",
 
202
        ""null""
 
203
      ]
 
204
    },
 
205
    ""Active"": {
 
206
      ""required"": true,
 
207
      ""type"": [
 
208
        ""boolean"",
 
209
        ""null""
 
210
      ]
 
211
    }
 
212
  }
 
213
}", json);
 
214
    }
 
215
 
 
216
    [Test]
 
217
    public void Generate_RequiredMembersClass()
 
218
    {
 
219
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
220
      JsonSchema schema = generator.Generate(typeof(RequiredMembersClass));
 
221
 
 
222
      Assert.AreEqual(JsonSchemaType.String, schema.Properties["FirstName"].Type);
 
223
      Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.Null, schema.Properties["MiddleName"].Type);
 
224
      Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.Null, schema.Properties["LastName"].Type);
 
225
      Assert.AreEqual(JsonSchemaType.String, schema.Properties["BirthDate"].Type);
 
226
    }
 
227
 
 
228
    [Test]
 
229
    public void Generate_Store()
 
230
    {
 
231
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
232
      JsonSchema schema = generator.Generate(typeof(Store));
 
233
 
 
234
      Assert.AreEqual(11, schema.Properties.Count);
 
235
 
 
236
      JsonSchema productArraySchema = schema.Properties["product"];
 
237
      JsonSchema productSchema = productArraySchema.Items[0];
 
238
 
 
239
      Assert.AreEqual(4, productSchema.Properties.Count);
 
240
    }
 
241
 
 
242
    [Test]
 
243
    public void MissingSchemaIdHandlingTest()
 
244
    {
 
245
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
246
 
 
247
      JsonSchema schema = generator.Generate(typeof(Store));
 
248
      Assert.AreEqual(null, schema.Id);
 
249
 
 
250
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
251
      schema = generator.Generate(typeof (Store));
 
252
      Assert.AreEqual(typeof(Store).FullName, schema.Id);
 
253
 
 
254
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseAssemblyQualifiedName;
 
255
      schema = generator.Generate(typeof(Store));
 
256
      Assert.AreEqual(typeof(Store).AssemblyQualifiedName, schema.Id);
 
257
    }
 
258
 
 
259
    [Test]
 
260
    public void CircularReferenceError()
 
261
    {
 
262
      ExceptionAssert.Throws<Exception>(@"Unresolved circular reference for type 'Newtonsoft.Json.Tests.TestObjects.CircularReferenceClass'. Explicitly define an Id for the type using a JsonObject/JsonArray attribute or automatically generate a type Id using the UndefinedSchemaIdHandling property.",
 
263
      () =>
 
264
      {
 
265
        JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
266
        generator.Generate(typeof(CircularReferenceClass));
 
267
      });
 
268
    }
 
269
 
 
270
    [Test]
 
271
    public void CircularReferenceWithTypeNameId()
 
272
    {
 
273
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
274
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
275
 
 
276
      JsonSchema schema = generator.Generate(typeof(CircularReferenceClass), true);
 
277
 
 
278
      Assert.AreEqual(JsonSchemaType.String, schema.Properties["Name"].Type);
 
279
      Assert.AreEqual(typeof(CircularReferenceClass).FullName, schema.Id);
 
280
      Assert.AreEqual(JsonSchemaType.Object | JsonSchemaType.Null, schema.Properties["Child"].Type);
 
281
      Assert.AreEqual(schema, schema.Properties["Child"]);
 
282
    }
 
283
 
 
284
    [Test]
 
285
    public void CircularReferenceWithExplicitId()
 
286
    {
 
287
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
288
 
 
289
      JsonSchema schema = generator.Generate(typeof(CircularReferenceWithIdClass));
 
290
 
 
291
      Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.Null, schema.Properties["Name"].Type);
 
292
      Assert.AreEqual("MyExplicitId", schema.Id);
 
293
      Assert.AreEqual(JsonSchemaType.Object | JsonSchemaType.Null, schema.Properties["Child"].Type);
 
294
      Assert.AreEqual(schema, schema.Properties["Child"]);
 
295
    }
 
296
 
 
297
    [Test]
 
298
    public void GenerateSchemaForType()
 
299
    {
 
300
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
301
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
302
 
 
303
      JsonSchema schema = generator.Generate(typeof(Type));
 
304
 
 
305
      Assert.AreEqual(JsonSchemaType.String, schema.Type);
 
306
 
 
307
      string json = JsonConvert.SerializeObject(typeof(Version), Formatting.Indented);
 
308
 
 
309
      JValue v = new JValue(json);
 
310
      Assert.IsTrue(v.IsValid(schema));
 
311
    }
 
312
 
 
313
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
 
314
    [Test]
 
315
    public void GenerateSchemaForISerializable()
 
316
    {
 
317
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
318
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
319
 
 
320
      JsonSchema schema = generator.Generate(typeof(Exception));
 
321
 
 
322
      Assert.AreEqual(JsonSchemaType.Object, schema.Type);
 
323
      Assert.AreEqual(true, schema.AllowAdditionalProperties);
 
324
      Assert.AreEqual(null, schema.Properties);
 
325
    }
 
326
#endif
 
327
 
 
328
#if !(NETFX_CORE || PORTABLE)
 
329
    [Test]
 
330
    public void GenerateSchemaForDBNull()
 
331
    {
 
332
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
333
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
334
 
 
335
      JsonSchema schema = generator.Generate(typeof(DBNull));
 
336
 
 
337
      Assert.AreEqual(JsonSchemaType.Null, schema.Type);
 
338
    }
 
339
 
 
340
    public class CustomDirectoryInfoMapper : DefaultContractResolver
 
341
    {
 
342
      public CustomDirectoryInfoMapper()
 
343
        : base(true)
 
344
      {
 
345
      }
 
346
 
 
347
      protected override JsonContract CreateContract(Type objectType)
 
348
      {
 
349
        if (objectType == typeof(DirectoryInfo))
 
350
          return base.CreateObjectContract(objectType);
 
351
 
 
352
        return base.CreateContract(objectType);
 
353
      }
 
354
 
 
355
      protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
 
356
      {
 
357
        IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
 
358
 
 
359
        JsonPropertyCollection c = new JsonPropertyCollection(type);
 
360
        CollectionUtils.AddRange(c, (IEnumerable)properties.Where(m => m.PropertyName != "Root"));
 
361
 
 
362
        return c;
 
363
      }
 
364
    }
 
365
 
 
366
    [Test]
 
367
    public void GenerateSchemaForDirectoryInfo()
 
368
    {
 
369
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
370
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
371
      generator.ContractResolver = new CustomDirectoryInfoMapper
 
372
        {
 
373
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
 
374
          IgnoreSerializableAttribute = true
 
375
#endif
 
376
        };
 
377
 
 
378
      JsonSchema schema = generator.Generate(typeof(DirectoryInfo), true);
 
379
 
 
380
      string json = schema.ToString();
 
381
      
 
382
      Assert.AreEqual(@"{
 
383
  ""id"": ""System.IO.DirectoryInfo"",
 
384
  ""required"": true,
 
385
  ""type"": [
 
386
    ""object"",
 
387
    ""null""
 
388
  ],
 
389
  ""additionalProperties"": false,
 
390
  ""properties"": {
 
391
    ""Name"": {
 
392
      ""required"": true,
 
393
      ""type"": [
 
394
        ""string"",
 
395
        ""null""
 
396
      ]
 
397
    },
 
398
    ""Parent"": {
 
399
      ""$ref"": ""System.IO.DirectoryInfo""
 
400
    },
 
401
    ""Exists"": {
 
402
      ""required"": true,
 
403
      ""type"": ""boolean""
 
404
    },
 
405
    ""FullName"": {
 
406
      ""required"": true,
 
407
      ""type"": [
 
408
        ""string"",
 
409
        ""null""
 
410
      ]
 
411
    },
 
412
    ""Extension"": {
 
413
      ""required"": true,
 
414
      ""type"": [
 
415
        ""string"",
 
416
        ""null""
 
417
      ]
 
418
    },
 
419
    ""CreationTime"": {
 
420
      ""required"": true,
 
421
      ""type"": ""string""
 
422
    },
 
423
    ""CreationTimeUtc"": {
 
424
      ""required"": true,
 
425
      ""type"": ""string""
 
426
    },
 
427
    ""LastAccessTime"": {
 
428
      ""required"": true,
 
429
      ""type"": ""string""
 
430
    },
 
431
    ""LastAccessTimeUtc"": {
 
432
      ""required"": true,
 
433
      ""type"": ""string""
 
434
    },
 
435
    ""LastWriteTime"": {
 
436
      ""required"": true,
 
437
      ""type"": ""string""
 
438
    },
 
439
    ""LastWriteTimeUtc"": {
 
440
      ""required"": true,
 
441
      ""type"": ""string""
 
442
    },
 
443
    ""Attributes"": {
 
444
      ""required"": true,
 
445
      ""type"": ""integer""
 
446
    }
 
447
  }
 
448
}", json);
 
449
 
 
450
      DirectoryInfo temp = new DirectoryInfo(@"c:\temp");
 
451
 
 
452
      JTokenWriter jsonWriter = new JTokenWriter();
 
453
      JsonSerializer serializer = new JsonSerializer();
 
454
      serializer.Converters.Add(new IsoDateTimeConverter());
 
455
      serializer.ContractResolver = new CustomDirectoryInfoMapper
 
456
        {
 
457
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
 
458
          IgnoreSerializableInterface = true
 
459
#endif
 
460
        };
 
461
      serializer.Serialize(jsonWriter, temp);
 
462
 
 
463
      List<string> errors = new List<string>();
 
464
      jsonWriter.Token.Validate(schema, (sender, args) => errors.Add(args.Message));
 
465
 
 
466
      Assert.AreEqual(0, errors.Count);
 
467
    }
 
468
#endif
 
469
 
 
470
    [Test]
 
471
    public void GenerateSchemaCamelCase()
 
472
    {
 
473
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
474
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
475
      generator.ContractResolver = new CamelCasePropertyNamesContractResolver()
 
476
        {
 
477
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
 
478
          IgnoreSerializableAttribute = true
 
479
#endif
 
480
        };
 
481
 
 
482
      JsonSchema schema = generator.Generate(typeof(Version), true);
 
483
 
 
484
      string json = schema.ToString();
 
485
 
 
486
      Assert.AreEqual(@"{
 
487
  ""id"": ""System.Version"",
 
488
  ""type"": [
 
489
    ""object"",
 
490
    ""null""
 
491
  ],
 
492
  ""additionalProperties"": false,
 
493
  ""properties"": {
 
494
    ""major"": {
 
495
      ""required"": true,
 
496
      ""type"": ""integer""
 
497
    },
 
498
    ""minor"": {
 
499
      ""required"": true,
 
500
      ""type"": ""integer""
 
501
    },
 
502
    ""build"": {
 
503
      ""required"": true,
 
504
      ""type"": ""integer""
 
505
    },
 
506
    ""revision"": {
 
507
      ""required"": true,
 
508
      ""type"": ""integer""
 
509
    },
 
510
    ""majorRevision"": {
 
511
      ""required"": true,
 
512
      ""type"": ""integer""
 
513
    },
 
514
    ""minorRevision"": {
 
515
      ""required"": true,
 
516
      ""type"": ""integer""
 
517
    }
 
518
  }
 
519
}", json);
 
520
    }
 
521
 
 
522
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
 
523
    [Test]
 
524
    public void GenerateSchemaSerializable()
 
525
    {
 
526
      JsonSchemaGenerator generator = new JsonSchemaGenerator();
 
527
      generator.ContractResolver = new DefaultContractResolver
 
528
        {
 
529
          IgnoreSerializableAttribute = false
 
530
        };
 
531
      generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
532
 
 
533
      JsonSchema schema = generator.Generate(typeof (Version), true);
 
534
 
 
535
      string json = schema.ToString();
 
536
 
 
537
      Assert.AreEqual(@"{
 
538
  ""id"": ""System.Version"",
 
539
  ""type"": [
 
540
    ""object"",
 
541
    ""null""
 
542
  ],
 
543
  ""additionalProperties"": false,
 
544
  ""properties"": {
 
545
    ""_Major"": {
 
546
      ""required"": true,
 
547
      ""type"": ""integer""
 
548
    },
 
549
    ""_Minor"": {
 
550
      ""required"": true,
 
551
      ""type"": ""integer""
 
552
    },
 
553
    ""_Build"": {
 
554
      ""required"": true,
 
555
      ""type"": ""integer""
 
556
    },
 
557
    ""_Revision"": {
 
558
      ""required"": true,
 
559
      ""type"": ""integer""
 
560
    }
 
561
  }
 
562
}", json);
 
563
 
 
564
      JTokenWriter jsonWriter = new JTokenWriter();
 
565
      JsonSerializer serializer = new JsonSerializer();
 
566
      serializer.ContractResolver  = new DefaultContractResolver
 
567
        {
 
568
          IgnoreSerializableAttribute = false
 
569
        };
 
570
      serializer.Serialize(jsonWriter, new Version(1, 2, 3, 4));
 
571
 
 
572
      List<string> errors = new List<string>();
 
573
      jsonWriter.Token.Validate(schema, (sender, args) => errors.Add(args.Message));
 
574
 
 
575
      Assert.AreEqual(0, errors.Count);
 
576
 
 
577
      Assert.AreEqual(@"{
 
578
  ""_Major"": 1,
 
579
  ""_Minor"": 2,
 
580
  ""_Build"": 3,
 
581
  ""_Revision"": 4
 
582
}", jsonWriter.Token.ToString());
 
583
 
 
584
      Version version = jsonWriter.Token.ToObject<Version>(serializer);
 
585
      Assert.AreEqual(1, version.Major);
 
586
      Assert.AreEqual(2, version.Minor);
 
587
      Assert.AreEqual(3, version.Build);
 
588
      Assert.AreEqual(4, version.Revision);
 
589
    }
 
590
#endif
 
591
 
 
592
    public enum SortTypeFlag
 
593
    {
 
594
      No = 0,
 
595
      Asc = 1,
 
596
      Desc = -1
 
597
    }
 
598
 
 
599
    public class X
 
600
    {
 
601
      public SortTypeFlag x;
 
602
    }
 
603
 
 
604
    [Test]
 
605
    public void GenerateSchemaWithNegativeEnum()
 
606
    {
 
607
      JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
 
608
      JsonSchema schema = jsonSchemaGenerator.Generate(typeof(X));
 
609
 
 
610
      string json = schema.ToString();
 
611
 
 
612
      Assert.AreEqual(@"{
 
613
  ""type"": ""object"",
 
614
  ""properties"": {
 
615
    ""x"": {
 
616
      ""required"": true,
 
617
      ""type"": ""integer"",
 
618
      ""enum"": [
 
619
        0,
 
620
        1,
 
621
        -1
 
622
      ],
 
623
      ""options"": [
 
624
        {
 
625
          ""value"": 0,
 
626
          ""label"": ""No""
 
627
        },
 
628
        {
 
629
          ""value"": 1,
 
630
          ""label"": ""Asc""
 
631
        },
 
632
        {
 
633
          ""value"": -1,
 
634
          ""label"": ""Desc""
 
635
        }
 
636
      ]
 
637
    }
 
638
  }
 
639
}", json);
 
640
    }
 
641
 
 
642
    [Test]
 
643
    public void CircularCollectionReferences()
 
644
    {
 
645
      Type type = typeof (Workspace);
 
646
      JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
 
647
 
 
648
      jsonSchemaGenerator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
649
      JsonSchema jsonSchema = jsonSchemaGenerator.Generate(type);
 
650
 
 
651
      // should succeed
 
652
      Assert.IsNotNull(jsonSchema);
 
653
    }
 
654
 
 
655
    [Test]
 
656
    public void CircularReferenceWithMixedRequires()
 
657
    {
 
658
      JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
 
659
 
 
660
      jsonSchemaGenerator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
661
      JsonSchema jsonSchema = jsonSchemaGenerator.Generate(typeof(CircularReferenceClass));
 
662
      string json = jsonSchema.ToString();
 
663
 
 
664
      Assert.AreEqual(@"{
 
665
  ""id"": ""Newtonsoft.Json.Tests.TestObjects.CircularReferenceClass"",
 
666
  ""type"": [
 
667
    ""object"",
 
668
    ""null""
 
669
  ],
 
670
  ""properties"": {
 
671
    ""Name"": {
 
672
      ""required"": true,
 
673
      ""type"": ""string""
 
674
    },
 
675
    ""Child"": {
 
676
      ""$ref"": ""Newtonsoft.Json.Tests.TestObjects.CircularReferenceClass""
 
677
    }
 
678
  }
 
679
}", json);
 
680
    }
 
681
 
 
682
    [Test]
 
683
    public void JsonPropertyWithHandlingValues()
 
684
    {
 
685
      JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
 
686
 
 
687
      jsonSchemaGenerator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
 
688
      JsonSchema jsonSchema = jsonSchemaGenerator.Generate(typeof(JsonPropertyWithHandlingValues));
 
689
      string json = jsonSchema.ToString();
 
690
 
 
691
      Assert.AreEqual(@"{
 
692
  ""id"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues"",
 
693
  ""required"": true,
 
694
  ""type"": [
 
695
    ""object"",
 
696
    ""null""
 
697
  ],
 
698
  ""properties"": {
 
699
    ""DefaultValueHandlingIgnoreProperty"": {
 
700
      ""type"": [
 
701
        ""string"",
 
702
        ""null""
 
703
      ],
 
704
      ""default"": ""Default!""
 
705
    },
 
706
    ""DefaultValueHandlingIncludeProperty"": {
 
707
      ""required"": true,
 
708
      ""type"": [
 
709
        ""string"",
 
710
        ""null""
 
711
      ],
 
712
      ""default"": ""Default!""
 
713
    },
 
714
    ""DefaultValueHandlingPopulateProperty"": {
 
715
      ""required"": true,
 
716
      ""type"": [
 
717
        ""string"",
 
718
        ""null""
 
719
      ],
 
720
      ""default"": ""Default!""
 
721
    },
 
722
    ""DefaultValueHandlingIgnoreAndPopulateProperty"": {
 
723
      ""type"": [
 
724
        ""string"",
 
725
        ""null""
 
726
      ],
 
727
      ""default"": ""Default!""
 
728
    },
 
729
    ""NullValueHandlingIgnoreProperty"": {
 
730
      ""type"": [
 
731
        ""string"",
 
732
        ""null""
 
733
      ]
 
734
    },
 
735
    ""NullValueHandlingIncludeProperty"": {
 
736
      ""required"": true,
 
737
      ""type"": [
 
738
        ""string"",
 
739
        ""null""
 
740
      ]
 
741
    },
 
742
    ""ReferenceLoopHandlingErrorProperty"": {
 
743
      ""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
 
744
    },
 
745
    ""ReferenceLoopHandlingIgnoreProperty"": {
 
746
      ""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
 
747
    },
 
748
    ""ReferenceLoopHandlingSerializeProperty"": {
 
749
      ""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
 
750
    }
 
751
  }
 
752
}", json);
 
753
    }
 
754
 
 
755
    [Test]
 
756
    public void GenerateForNullableInt32()
 
757
    {
 
758
      JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
 
759
 
 
760
      JsonSchema jsonSchema = jsonSchemaGenerator.Generate(typeof(NullableInt32TestClass));
 
761
      string json = jsonSchema.ToString();
 
762
 
 
763
      Assert.AreEqual(@"{
 
764
  ""type"": ""object"",
 
765
  ""properties"": {
 
766
    ""Value"": {
 
767
      ""required"": true,
 
768
      ""type"": [
 
769
        ""integer"",
 
770
        ""null""
 
771
      ]
 
772
    }
 
773
  }
 
774
}", json);
 
775
    }
 
776
  }
 
777
 
 
778
  public class NullableInt32TestClass
 
779
  {
 
780
    public int? Value { get; set; }
 
781
  }
 
782
 
 
783
  public class DMDSLBase
 
784
  {
 
785
    public String Comment;
 
786
  }
 
787
 
 
788
  public class Workspace : DMDSLBase
 
789
  {
 
790
    public ControlFlowItemCollection Jobs = new ControlFlowItemCollection();
 
791
  }
 
792
 
 
793
  public class ControlFlowItemBase : DMDSLBase
 
794
  {
 
795
    public String Name;
 
796
  }
 
797
 
 
798
  public class ControlFlowItem : ControlFlowItemBase//A Job
 
799
  {
 
800
    public TaskCollection Tasks = new TaskCollection();
 
801
    public ContainerCollection Containers = new ContainerCollection();
 
802
  }
 
803
 
 
804
  public class ControlFlowItemCollection : List<ControlFlowItem>
 
805
  {
 
806
  }
 
807
 
 
808
  public class Task : ControlFlowItemBase
 
809
  {
 
810
    public DataFlowTaskCollection DataFlowTasks = new DataFlowTaskCollection();
 
811
    public BulkInsertTaskCollection BulkInsertTask = new BulkInsertTaskCollection();
 
812
  }
 
813
 
 
814
  public class TaskCollection : List<Task>
 
815
  {
 
816
  }
 
817
 
 
818
  public class Container : ControlFlowItemBase
 
819
  {
 
820
    public ControlFlowItemCollection ContainerJobs = new ControlFlowItemCollection();
 
821
  }
 
822
 
 
823
  public class ContainerCollection : List<Container>
 
824
  {
 
825
  }
 
826
 
 
827
  public class DataFlowTask_DSL : ControlFlowItemBase
 
828
  {
 
829
  }
 
830
 
 
831
  public class DataFlowTaskCollection : List<DataFlowTask_DSL>
 
832
  {
 
833
  }
 
834
 
 
835
  public class SequenceContainer_DSL : Container
 
836
  {
 
837
  }
 
838
 
 
839
  public class BulkInsertTaskCollection : List<BulkInsertTask_DSL>
 
840
  {
 
841
  }
 
842
 
 
843
  public class BulkInsertTask_DSL
 
844
  {
 
845
  }
 
846
}
 
 
b'\\ No newline at end of file'