public void ParseTermInChild()
{
// Arrange
var doc = new JObject(new JProperty("foo", "bar"),
new JProperty("child",
new JObject(new JProperty("Ick", "much"), new JProperty("Ock", "wow"))));
var localObject = new LocalType();
// Act
var root = new VocabTerm <LocalType>();
var child = new VocabTerm <LocalChildType>("child");
child.MapProperty <string>("Ick", (s, o) => s.Ick = o);
child.MapProperty <string>("Ock", (s, o) => s.Ock = o);
root.MapObject <LocalChildType>(child, (s) =>
{
var subject = s;
subject.Child = new LocalChildType();
return(subject.Child);
});
JsonStreamingParser.ParseStream(doc.ToMemoryStream(), localObject, root);
// Assert
Assert.Equal("much", localObject.Child.Ick);
Assert.Equal("wow", localObject.Child.Ock);
}
public void ParseAPIsJsonDocumentMinimal()
{
var stream = this.GetType().Assembly.GetManifestResourceStream(this.GetType(), "apis.json");
var rootMap = new VocabTerm <ApisJson>(null);
rootMap.MapProperty <string>("name", (s, o) => s.Name = o);
rootMap.MapProperty <string>("url", (s, o) => s.Url = new Uri(o));
var apiMap = new VocabTerm <ApisJsonApi>("apis");
apiMap.MapProperty <string>("name", (s, o) => s.Name = o);
apiMap.MapProperty <string>("description", (s, o) => s.Name = o);
apiMap.MapProperty <string>("baseUrl", (s, o) => s.BaseUrl = new Uri(o));
rootMap.MapObject <ApisJsonApi>(apiMap, (s) =>
{
if (s.Apis == null)
{
s.Apis = new List <ApisJsonApi>();
}
var api = new ApisJsonApi();
s.Apis.Add(api);
return(api);
});
var apis = new ApisJson();
JsonStreamingParser.ParseStream(stream, apis, rootMap);
Assert.Equal("API Evangelist", apis.Name);
Assert.Equal(2, apis.Apis.Count());
}
public void ParseTermInChild()
{
// Arrange
var doc = new JObject(new JProperty("foo", "bar"),
new JProperty("child",
new JObject(new JProperty("Ick", "much"), new JProperty("Ock", "wow"))));
var localObject = new LocalType();
// Act
var root = new VocabTerm<LocalType>();
var child = new VocabTerm<LocalChildType>("child");
child.MapProperty<string>("Ick", (s, o) => s.Ick = o);
child.MapProperty<string>("Ock", (s, o) => s.Ock = o);
root.MapObject<LocalChildType>(child, (s) =>
{
var subject = s;
subject.Child = new LocalChildType();
return subject.Child;
});
JsonStreamingParser.ParseStream(doc.ToMemoryStream(), localObject, root);
// Assert
Assert.Equal("much", localObject.Child.Ick);
Assert.Equal("wow", localObject.Child.Ock);
}
public void ParseSwaggerPaths()
{
var opsTerm = new VocabTerm <Operation>();
var pathTerm = new VocabTerm <Path>();
pathTerm.MapAnyObject <Operation>(opsTerm, (s, p) => {
return(s.AddOperation(p, Guid.NewGuid().ToString()));
});
var pathsTerm = new VocabTerm <OpenApiDocument>("paths");
pathsTerm.MapAnyObject <Path>(pathTerm, (s, p) => {
return(s.AddPath(p));
});
var rootTerm = new VocabTerm <OpenApiDocument>();
rootTerm.MapObject <OpenApiDocument>(pathsTerm, (s) =>
{
return(s);
});
var stream = this.GetType().Assembly
.GetManifestResourceStream(this.GetType(), "forecast.io.swagger.json");
var swaggerDoc = new OpenApiDocument();
JsonStreamingParser.ParseStream(stream, swaggerDoc, rootTerm);
Assert.Equal(1, swaggerDoc.Paths.Count);
Assert.Equal(1, swaggerDoc.Paths.First().Value.Operations.Count());
}
public static VocabTerm<OpenApiDocument> Create()
{
var openApiTerm = new VocabTerm<OpenApiDocument>();
openApiTerm.MapProperty<string>("swagger", (s, o) => s.Version = o);
openApiTerm.MapProperty<string>("schemes", (s, o) =>
{
if (s.Schemes == null) s.Schemes = new List<String>();
s.Schemes.Add(o);
});
var infoTerm = new VocabTerm<Info>("info");
infoTerm.MapProperty<string>("description",(s,o) => s.Description = o);
infoTerm.MapProperty<string>("termsOfService", (s, o) => s.TermsOfService = o);
infoTerm.MapProperty<string>("title", (s, o) => s.Title = o);
openApiTerm.MapObject<Info>(infoTerm, (s) =>
{
s.Info = new Info();
return s.Info;
});
var contactTerm = new VocabTerm<Contact>("contact");
infoTerm.MapObject<Contact>(contactTerm, (s) =>
{
s.Contact = new Contact();
return s.Contact;
});
var opsTerm = new VocabTerm<Operation>();
opsTerm.MapProperty<string>("operationId", (s, o) => s.Id = o);
//opsTerm.MapProperty<string>("x-controller", (s, o) => s. = o);
var pathTerm = new VocabTerm<Path>();
pathTerm.MapAnyObject<Operation>(opsTerm, (s, p) => {
return s.AddOperation(p, Guid.NewGuid().ToString());
});
var pathsTerm = new VocabTerm<OpenApiDocument>("paths");
pathsTerm.MapAnyObject<Path>(pathTerm, (s, p) => {
return s.AddPath(p);
});
openApiTerm.MapObject<OpenApiDocument>(pathsTerm, (s) =>
{
return s;
});
return openApiTerm;
}
public void GetGlobalTerm()
{
var termFoo = new VocabTerm("foo");
var termBar = new VocabTerm("bar");
var termBaz = new VocabTerm("baz");
var rootTerm = new VocabTerm(null);
rootTerm.AddChild(termFoo.Term,termFoo);
rootTerm.AddChild(termBar.Term,termBar);
rootTerm.AddChild(termBaz.Term,termBaz);
Assert.Equal(termFoo, rootTerm.Find("foo"));
Assert.Null(rootTerm.Find("fooz"));
Assert.Equal(termBaz, rootTerm.Find("baz"));
}
public void GetGlobalTerm()
{
var termFoo = new VocabTerm("foo");
var termBar = new VocabTerm("bar");
var termBaz = new VocabTerm("baz");
var rootTerm = new VocabTerm(null);
rootTerm.AddChild(termFoo.Term, termFoo);
rootTerm.AddChild(termBar.Term, termBar);
rootTerm.AddChild(termBaz.Term, termBaz);
Assert.Equal(termFoo, rootTerm.Find("foo"));
Assert.Null(rootTerm.Find("fooz"));
Assert.Equal(termBaz, rootTerm.Find("baz"));
}
public void ParseTerm()
{
// Arrange
var doc = new JObject(new JProperty("foo", "bar"), new JProperty("baz", 22));
var localObject = new LocalType();
// Act
var rootMap = new VocabTerm <LocalType>();
rootMap.MapProperty <string>("foo", (s, o) => s.Foo = o);
rootMap.MapProperty <int>("baz", (s, o) => s.Baz = o);
JsonStreamingParser.ParseStream(doc.ToMemoryStream(), localObject, rootMap);
// Assert
Assert.Equal("bar", localObject.Foo);
Assert.Equal(22, localObject.Baz);
}
public void ParseTerm()
{
// Arrange
var doc = new JObject(new JProperty("foo", "bar"), new JProperty("baz", 22));
var localObject = new LocalType();
// Act
var rootMap = new VocabTerm<LocalType>();
rootMap.MapProperty<string>("foo", (s, o) => s.Foo = o);
rootMap.MapProperty<int>("baz", (s, o) => s.Baz = o);
JsonStreamingParser.ParseStream(doc.ToMemoryStream(), localObject, rootMap);
// Assert
Assert.Equal("bar", localObject.Foo);
Assert.Equal(22, localObject.Baz);
}
public void ParseProblemDocument()
{
var stream = this.GetType().Assembly.GetManifestResourceStream("Hapikit.net.Tests.problem.json");
Func <string, Uri> typeProducer = (o) => new Uri(o);
var vocab = new VocabTerm <ProblemDocument>();
vocab.MapProperty <string>("type", (s, o) => { s.ProblemType = typeProducer(o); });
vocab.MapProperty <string>("title", (s, o) => { s.Title = o; });
vocab.MapProperty <string>("detail", (s, o) => { s.Detail = o; });
vocab.MapProperty <string>("instance", (s, o) => { s.ProblemInstance = new Uri(o, UriKind.RelativeOrAbsolute); });
var problem = new Tavis.ProblemDocument();
JsonStreamingParser.ParseStream(stream, problem, vocab);
Assert.Equal("https://example.com/probs/out-of-credit", problem.ProblemType.OriginalString);
Assert.Equal("You do not have enough credit.", problem.Title);
}
// [Fact]
public void ParseVeryLargeSwaggerPaths()
{
var opsTerm = new VocabTerm <Operation>();
var pathTerm = new VocabTerm <Path>();
pathTerm.MapAnyObject <Operation>(opsTerm, (s, p) =>
{
return(s.AddOperation(p, Guid.NewGuid().ToString()));
});
var pathsTerm = new VocabTerm <OpenApiDocument>("paths");
pathsTerm.MapAnyObject <Path>(pathTerm, (s, p) =>
{
return(s.AddPath(p));
});
var rootTerm = new VocabTerm <OpenApiDocument>();
rootTerm.MapObject <OpenApiDocument>(pathsTerm, (s) =>
{
return(s);
});
var swaggerDoc = new OpenApiDocument();
var sw = new Stopwatch();
using (var stream = File.OpenRead(@"C:\Users\Darrel\Documents\Swagger\WebSites.json"))
{
sw.Start();
JsonStreamingParser.ParseStream(stream, swaggerDoc, rootTerm);
sw.Stop();
};
_output.WriteLine(swaggerDoc.Paths.Count.ToString());
_output.WriteLine("That took : " + sw.ElapsedMilliseconds);
}
// [Fact]
public void ParseVeryLargeSwaggerPaths()
{
var opsTerm = new VocabTerm<Operation>();
var pathTerm = new VocabTerm<Path>();
pathTerm.MapAnyObject<Operation>(opsTerm, (s, p) =>
{
return s.AddOperation(p, Guid.NewGuid().ToString());
});
var pathsTerm = new VocabTerm<OpenApiDocument>("paths");
pathsTerm.MapAnyObject<Path>(pathTerm, (s, p) =>
{
return s.AddPath(p);
});
var rootTerm = new VocabTerm<OpenApiDocument>();
rootTerm.MapObject<OpenApiDocument>(pathsTerm, (s) =>
{
return s;
});
var swaggerDoc = new OpenApiDocument();
var sw = new Stopwatch();
using (var stream = File.OpenRead(@"C:\Users\Darrel\Documents\Swagger\WebSites.json"))
{
sw.Start();
JsonStreamingParser.ParseStream(stream, swaggerDoc, rootTerm);
sw.Stop();
};
_output.WriteLine(swaggerDoc.Paths.Count.ToString());
_output.WriteLine("That took : " + sw.ElapsedMilliseconds);
}
public static void ParseStream(Stream stream, object rootSubject, VocabTerm rootTerm)
{
using (var reader = new JsonTextReader(new StreamReader(stream)))
{
var ostack = new Stack<Context>();
Context currentContext = null;
Func<Context, object, Context> currentParser = null;
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.StartObject:
if (currentContext == null)
{
currentContext = new Context(rootSubject, rootTerm);
currentParser = rootTerm.Parser;
}
else
{
// Save current context before creating new context
ostack.Push(currentContext);
if (currentParser != null) // If we have a handler to create a new context object
{
// Update to new Context unless we are walking an Array of objects
var newContext = currentParser(currentContext, currentContext.LastProperty);
if (newContext != null)
{
currentContext = newContext;
}
}
else
{
currentContext = new Context(null, null); // Unknown object
}
}
DiagSource?.Write("Hapikit.JsonStreamingParser.NewObject", currentContext);
break;
case JsonToken.StartArray:
DiagSource?.Write("Hapikit.JsonStreamingParser.StartArray", currentContext);
break;
case JsonToken.EndArray:
DiagSource?.Write("Hapikit.JsonStreamingParser.EndArray", currentContext);
break;
case JsonToken.EndObject:
// Update context object
DiagSource?.Write("Hapikit.JsonStreamingParser.EndObject", currentContext);
if (ostack.Count > 0)
{
currentParser = currentContext.TermMap?.Parser;
currentContext = ostack.Pop();
}
break;
case JsonToken.PropertyName:
// Determine new VocabTerm based on new Property
currentContext.LastProperty = reader.Value.ToString();
currentParser = currentContext.TermMap?.FindParser(currentContext.LastProperty);
DiagSource?.Write("Hapikit.JsonStreamingParser.PropertyName", currentContext.TermMap);
break;
case JsonToken.Integer:
case JsonToken.Boolean:
case JsonToken.String:
// Use VocabTerm Parser to Update Subject based on the current Term.
if (currentParser != null)
{
DiagSource?.Write("Hapikit.JsonStreamingParser.PropertyValue", reader.Value);
currentParser(currentContext, reader.Value);
}
else
{
DiagSource?.Write("Hapikit.JsonStreamingParser.MissingTermHandler", new { Context = currentContext, Value = reader.Value });
}
break;
}
}
}
}
public static VocabTerm <ApisJson> Create()
{
var vocab = new VocabTerm <ApisJson>();
vocab.MapProperty <string>("name", (s, o) => s.Name = o);
vocab.MapProperty <string>("description", (s, o) => s.Description = o);
vocab.MapProperty <string>("url", (s, o) => s.Url = new Uri(o));
vocab.MapProperty <string>("image", (s, o) => s.Image = new Uri(o));
vocab.MapProperty <string>("modified", (s, o) => s.Modified = DateTime.Parse(o));
vocab.MapProperty <string>("created", (s, o) => s.Created = DateTime.Parse(o));
vocab.MapProperty <string>("tags", (s, o) =>
{
if (s.Tags == null)
{
s.Tags = new List <string>();
}
s.Tags.Add(o);
});
vocab.MapProperty <string>("specificationVersion", (s, o) => s.SpecificationVersion = o);
var apivocab = new VocabTerm <ApisJsonApi>("apis");
apivocab.MapProperty <string>("name", (s, o) => s.Name = o);
apivocab.MapProperty <string>("description", (s, o) => s.Name = o);
apivocab.MapProperty <string>("humanUrl", (s, o) => s.HumanUrl = new Uri(o));
apivocab.MapProperty <string>("baseUrl", (s, o) => s.BaseUrl = new Uri(o));
apivocab.MapProperty <string>("version", (s, o) => s.Version = o);
apivocab.MapProperty <string>("image", (s, o) => s.Image = new Uri(o));
apivocab.MapProperty <string>("tags", (s, o) =>
{
if (s.Tags == null)
{
s.Tags = new List <string>();
}
s.Tags.Add(o);
}
);
vocab.MapObject <ApisJsonApi>(apivocab, (s) =>
{
var api = new ApisJsonApi();
s.Apis.Add(api);
return(api);
}
);
// Properties
var propertyTerm = new VocabTerm <ApisJsonProperty>("properties");
propertyTerm.MapProperty <string>("url", (s, o) => s.Url = new Uri(o));
propertyTerm.MapProperty <string>("type", (s, o) => s.Type = o);
apivocab.MapObject <ApisJsonProperty>(propertyTerm, (s) =>
{
var property = new ApisJsonProperty();
s.Properties.Add(property);
return(property);
}
);
// Contact
var contactTerm = new VocabTerm <ApisJsonContact>("contact");
contactTerm.MapProperty <string>("fn", (s, o) => s.Url = new Uri(o));
contactTerm.MapProperty <string>("email", (s, o) => s.Email = o);
contactTerm.MapProperty <string>("url", (s, o) => s.Url = new Uri(o));
contactTerm.MapProperty <string>("org", (s, o) => s.Org = o);
contactTerm.MapProperty <string>("adr", (s, o) => s.Adr = o);
contactTerm.MapProperty <string>("tel", (s, o) => s.Tel = o);
contactTerm.MapProperty <string>("x-twitter", (s, o) => s.Twitter = o);
contactTerm.MapProperty <string>("x-github", (s, o) => s.Github = o);
contactTerm.MapProperty <string>("photo", (s, o) => s.Photo = new Uri(o));
contactTerm.MapProperty <string>("vcard", (s, o) => s.VCard = new Uri(o));
apivocab.MapObject <ApisJsonContact>(contactTerm, (s) =>
{
s.Contact = new ApisJsonContact();
return(s.Contact);
}
);
// Include
var includeTerm = new VocabTerm <ApisJsonInclude>("include");
includeTerm.MapProperty <string>("name", (s, o) => s.Name = o);
includeTerm.MapProperty <string>("url", (s, o) => s.Url = new Uri(o));
vocab.MapObject <ApisJsonInclude>(includeTerm, (s) =>
{
var include = new ApisJsonInclude();
s.Includes.Add(include);
return(include);
}
);
//Maintainers
var maintainers = contactTerm.Clone <ApisJson>("maintainers");
vocab.MapObject <ApisJsonContact>(maintainers, (s) =>
{
var contact = new ApisJsonContact();
s.Maintainers.Add(contact);
return(contact);
}
);
return(vocab);
}
public void ParseAPIsJsonDocumentMinimal()
{
var stream = this.GetType().Assembly.GetManifestResourceStream(this.GetType(), "apis.json");
var rootMap = new VocabTerm<ApisJson>(null);
rootMap.MapProperty<string>("name", (s, o) => s.Name = o );
rootMap.MapProperty<string>("url", (s, o) => s.Url = new Uri(o));
var apiMap = new VocabTerm<ApisJsonApi>("apis");
apiMap.MapProperty<string>("name", (s, o) => s.Name = o);
apiMap.MapProperty<string>("description", (s, o) => s.Name = o);
apiMap.MapProperty<string>("baseUrl", (s, o) => s.BaseUrl = new Uri(o));
rootMap.MapObject<ApisJsonApi>(apiMap, (s) =>
{
if (s.Apis == null)
{
s.Apis = new List<ApisJsonApi>();
}
var api = new ApisJsonApi();
s.Apis.Add(api);
return api;
});
var apis = new ApisJson();
JsonStreamingParser.ParseStream(stream, apis, rootMap);
Assert.Equal("API Evangelist", apis.Name);
Assert.Equal(2, apis.Apis.Count());
}
public void ParseSwaggerPaths()
{
var opsTerm = new VocabTerm<Operation>();
var pathTerm = new VocabTerm<Path>();
pathTerm.MapAnyObject<Operation>(opsTerm, (s, p) => {
return s.AddOperation(p, Guid.NewGuid().ToString());
});
var pathsTerm = new VocabTerm<OpenApiDocument>("paths");
pathsTerm.MapAnyObject<Path>(pathTerm,(s,p) => {
return s.AddPath(p);
});
var rootTerm = new VocabTerm<OpenApiDocument>();
rootTerm.MapObject<OpenApiDocument>(pathsTerm, (s) =>
{
return s;
});
var stream = this.GetType().Assembly
.GetManifestResourceStream(this.GetType(), "forecast.io.swagger.json");
var swaggerDoc = new OpenApiDocument();
JsonStreamingParser.ParseStream(stream, swaggerDoc, rootTerm);
Assert.Equal(1, swaggerDoc.Paths.Count);
Assert.Equal(1, swaggerDoc.Paths.First().Value.Operations.Count());
}
public Context(object subject, VocabTerm term)
{
Subject = subject;
TermMap = term;
}
public void ParseProblemDocument()
{
var stream = this.GetType().Assembly.GetManifestResourceStream("Hapikit.net.Tests.problem.json");
Func<string, Uri> typeProducer = (o) => new Uri(o);
var vocab = new VocabTerm<ProblemDocument>();
vocab.MapProperty<string>("type", (s, o) => { s.ProblemType = typeProducer(o); });
vocab.MapProperty<string>("title", (s, o) => { s.Title = o; });
vocab.MapProperty<string>("detail", (s, o) => { s.Detail = o; });
vocab.MapProperty<string>("instance", (s, o) => { s.ProblemInstance = new Uri(o,UriKind.RelativeOrAbsolute); });
var problem = new Tavis.ProblemDocument();
JsonStreamingParser.ParseStream(stream, problem, vocab);
Assert.Equal("https://example.com/probs/out-of-credit", problem.ProblemType.OriginalString);
Assert.Equal("You do not have enough credit.", problem.Title);
}
