public async Task ShouldBuild_WhenChinook()
{
var model = await BuildModel("files/raml1/chinook-v1.raml");
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("InvoiceLine"), model.Objects.First(c => c.Name == "Invoice").Properties.First(p => p.Name == "Lines").Type);
Assert.AreEqual("ArtistByTrack", model.Objects.First(c => c.Name == "ArtistByTrack").Type);
Assert.AreEqual("Dictionary<string,Artist>", model.Objects.First(c => c.Name == "ArtistByTrack").BaseClass);
Assert.AreEqual("TracksByArtist", model.Objects.First(c => c.Name == "TracksByArtist").Type);
Assert.AreEqual("Dictionary<string,Track[]>", model.Objects.First(c => c.Name == "TracksByArtist").BaseClass);
Assert.AreEqual("ArtistByTrack", model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Url == "bytrack/{id}").ReturnType);
Assert.AreEqual("TracksByArtist", model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Url == "byartist/{id}").ReturnType);
Assert.AreEqual("Artist", model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Album", model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Track", model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Customer", model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Artist"), model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Album"), model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Customer"), model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Track"), model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual("Artist", model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Album", model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Customer", model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Track", model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "Post").Parameter.Type);
}
public async Task ShouldBuild_EvenWithIncludedDisorderedTypes()
{
var model = await BuildModel("files/raml1/types-order-includes.raml");
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("InvoiceLine"), model.Objects.First(c => c.Name == "Invoice").Properties.First(p => p.Name == "Lines").Type);
Assert.AreEqual("Artist", model.Objects.First(c => c.Name == "Artist").Type);
Assert.AreEqual(2, model.Objects.First(c => c.Name == "Artist").Properties.Count());
Assert.AreEqual(3, model.Objects.First(c => c.Name == "Album").Properties.Count());
Assert.AreEqual("Artist", model.Objects.First(c => c.Name == "Album").Properties.First(m => m.Name == "Artist").Type);
Assert.AreEqual("Artist", model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Album", model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Track", model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual("Customer", model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "GetById").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Artist"), model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Album"), model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Customer"), model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Track"), model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual("Artist", model.Controllers.First(c => c.Name == "Artists").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Album", model.Controllers.First(c => c.Name == "Albums").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Customer", model.Controllers.First(c => c.Name == "Customers").Methods.First(m => m.Name == "Post").Parameter.Type);
Assert.AreEqual("Track", model.Controllers.First(c => c.Name == "Tracks").Methods.First(m => m.Name == "Post").Parameter.Type);
}
private void ParseArray(IDictionary <string, ApiObject> objects, JsonSchema schema, Property prop, KeyValuePair <string, JsonSchema> property, IDictionary <string, ApiEnum> enums)
{
if (schema.Items == null || !schema.Items.Any())
{
return;
}
var netType = NetTypeMapper.GetNetType(schema.Items.First().Type, property.Value.Format);
if (netType != null)
{
prop.Type = CollectionTypeHelper.GetCollectionType(netType);
}
else
{
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(property.Key));
foreach (var item in schema.Items)
{
var modifiedKey = ParseObject(property.Key, item, objects, enums);
if (modifiedKey != null)
{
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(modifiedKey));
}
}
}
}
public void should_parse_bodyless_arrays()
{
const string schema =
" { \"$schema\": \"http://json-schema.org/draft-03/schema\",\r\n" +
" \"type\": \"object\",\r\n" +
" \"description\": \"A single support status\",\r\n" +
" \"properties\": {\r\n" +
" \"id\": { \"type\": \"string\", \"required\": true },\r\n" +
" \"names\": { \"type\": \"array\", \"required\": true },\r\n" +
" \"titles\": { \"type\": \"array\", \r\n" +
" \"items\": \r\n" +
" {\r\n" +
" \"type\": \"object\",\r\n" +
" \"properties\": \r\n" +
" {\r\n" +
" \"id\": { \"type\": \"string\", \"required\": true },\r\n" +
" \"at\": { \"type\": \"string\", \"required\": true }\r\n" +
" }\r\n" +
" }\r\n" +
" }\r\n" +
" }\r\n" +
" }\r\n";
var parser = new JsonSchemaParser();
var warnings = new Dictionary <string, string>();
var objects = new Dictionary <string, ApiObject>();
var enums = new Dictionary <string, ApiEnum>();
var obj = parser.Parse("name", schema, objects, warnings, enums, new Dictionary <string, ApiObject>(), new Dictionary <string, ApiObject>());
Assert.AreEqual(3, obj.Properties.Count);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("string"), obj.Properties.First(p => p.Name == "Names").Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Titles"), obj.Properties.First(p => p.Name == "Titles").Type);
}
public async Task ShouldHandleTypeExpressions()
{
var model = await GetTypeExpressionsModel();
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Movie"), model.Classes.First().Methods.First(m => m.Verb == "Get").OkReturnType);
Assert.AreEqual("string", model.Classes.First().Methods.First(m => m.Verb == "Put").Parameter.Type);
Assert.AreEqual("string", model.Classes.First().Methods.First(m => m.Verb == "Post").Parameter.Type);
}
public async Task ShouldDetectArrayTypes_WhenMovies()
{
var model = await GetMoviesModel();
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Movie"), model.Controllers.First(o => o.Name == "Movies").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Movie"), model.Controllers.First(o => o.Name == "Movies").Methods.First(m => m.Name == "GetAvailable").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Movie"), model.Controllers.First(o => o.Name == "Search").Methods.First(m => m.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Movie"), model.Controllers.First(o => o.Name == "Movies").Methods.First(m => m.Name == "Post").Parameter.Type);
}
public async Task ShouldHandleCasing()
{
var model = await BuildModel("files/raml1/case.raml");
Assert.IsNotNull(model.Objects.First(c => c.Name == "Person"));
Assert.IsNotNull(model.Objects.First(c => c.Name == "Customer"));
Assert.AreEqual("Person", model.Objects.First(c => c.Name == "Customer").BaseClass);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Controllers.First(c => c.Name == "Persons").Methods.First(m => m.Verb == "Post").Parameter.Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Controllers.First(c => c.Name == "Persons").Methods.First(m => m.Verb == "Get").ReturnType);
}
public async Task ShouldHandleDates()
{
var model = await BuildModel("files/raml1/dates.raml");
Assert.AreEqual(3, model.Objects.Count());
Assert.AreEqual("DateTime", model.Objects.First(x => x.Name == "Person").Properties.First(x => x.Name == "Born").Type);
Assert.AreEqual("DateTime", model.Objects.First(x => x.Name == "User").Properties.First(x => x.Name == "Lastaccess").Type);
Assert.AreEqual("DateTime", model.Objects.First(x => x.Name == "Sample").Properties.First(x => x.Name == "Prop1").Type);
Assert.AreEqual("DateTime", model.Objects.First(x => x.Name == "Sample").Properties.First(x => x.Name == "Prop2").Type);
Assert.AreEqual("DateTimeOffset", model.Objects.First(x => x.Name == "Sample").Properties.First(x => x.Name == "Prop3").Type);
Assert.AreEqual("DateTime", model.Controllers.First(x => x.Name == "Access").Methods.First(x => x.Name == "Post").Parameter.Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("DateTime"), model.Controllers.First(x => x.Name == "Access").Methods.First(x => x.Name == "Get").ReturnType);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("DateTime"), model.Controllers.First(x => x.Name == "Persons").Methods.First(x => x.Name == "Put").Parameter.Type);
}
private static string GetType(KeyValuePair <string, JsonSchema> property, bool isEnum, string enumName)
{
if (isEnum)
{
return(enumName);
}
var type = NetTypeMapper.Map(property.Value.Type);
if (!string.IsNullOrWhiteSpace(type))
{
if (type == "string" || (property.Value.Required != null && property.Value.Required.Value))
{
return(type);
}
return(type + "?");
}
if (HasMultipleTypes(property))
{
return(HandleMultipleTypes(property));
}
if (!string.IsNullOrWhiteSpace(property.Value.Id))
{
return(NetNamingMapper.GetObjectName(property.Value.Id));
}
// if it is a "body less" array then I assume it's an array of strings
if (property.Value.Type == JsonSchemaType.Array && (property.Value.Items == null || !property.Value.Items.Any()))
{
return(CollectionTypeHelper.GetCollectionType("string"));
}
// if it is a "body less" object then use object as the type
if (property.Value.Type == JsonSchemaType.Object && (property.Value.Properties == null || !property.Value.Properties.Any()))
{
return("object");
}
if (property.Value == null)
{
return(null);
}
return(NetNamingMapper.GetObjectName(property.Key));
}
private void ParseArray(IDictionary <string, ApiObject> objects, Newtonsoft.JsonV4.Schema.JsonSchema schema, Property prop, KeyValuePair <string, Newtonsoft.JsonV4.Schema.JsonSchema> property, IDictionary <string, ApiEnum> enums)
{
var netType = NetTypeMapper.Map(schema.Items.First().Type);
if (netType != null)
{
prop.Type = CollectionTypeHelper.GetCollectionType(netType);
}
else
{
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(property.Key));
foreach (var item in schema.Items)
{
ParseObject(property.Key, item.Properties, objects, enums, item);
}
}
}
public async Task ShouldHandleUnionTypes()
{
var model = await BuildModel("files/raml1/uniontypes.raml");
Assert.AreEqual(5, model.Objects.Count());
Assert.AreEqual(2, model.Objects.First(c => c.Name == "Customer").Properties.Count);
Assert.AreEqual("Person", model.Objects.First(c => c.Name == "Customer").Properties.First(c => c.Name == "Person").Type);
Assert.AreEqual("Company", model.Objects.First(c => c.Name == "Customer").Properties.First(c => c.Name == "Company").Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Objects.First(c => c.Name == "Customers").Properties.First(c => c.Name == "Person").Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Company"), model.Objects.First(c => c.Name == "Customers").Properties.First(c => c.Name == "Company").Type);
Assert.AreEqual(false, model.Objects.First(c => c.Name == "Group").IsArray);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Objects.First(c => c.Name == "Group").Properties.First(c => c.Name == "Person").Type);
Assert.AreEqual("Company", model.Objects.First(c => c.Name == "Group").Properties.First(c => c.Name == "Company").Type);
}
public void GenerateCode(RamlInfo data, string targetNamespace, string clientRootClassName, string ramlDestFile, string destFolderPath,
string destFolderName, ProjectItem ramlProjItem)
{
ThreadHelper.ThrowIfNotOnUIThread();
//var ramlInfo = await RamlInfoService.GetRamlInfo(ramlDestFile);
//if (ramlInfo.HasErrors)
//{
// ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, ramlInfo.ErrorMessage);
// MessageBox.Show(ramlInfo.ErrorMessage);
// return;
//}
var model = new ClientGeneratorService(data.RamlDocument, clientRootClassName, targetNamespace, targetNamespace + ".Models").BuildModel();
var directoryName = Path.GetDirectoryName(ramlDestFile).TrimEnd(Path.DirectorySeparatorChar);
var templateFolder = directoryName.Substring(0, directoryName.LastIndexOf(Path.DirectorySeparatorChar)) +
Path.DirectorySeparatorChar + "Templates" + Path.DirectorySeparatorChar;
var templateFilePath = Path.Combine(templateFolder, ClientT4TemplateName);
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
// when array has no properties, set it collection on base type
foreach (var arrayModel in model.Objects.Where(o => o.IsArray && o.Properties.Count == 0 && o.Type != null &&
CollectionTypeHelper.IsCollection(o.Type) && !NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(o.Type))))
{
arrayModel.BaseClass = arrayModel.Type.Substring(1); // remove the initil "I" to make it a concrete class
}
var t4Service = new T4Service(ServiceProvider);
var res = t4Service.TransformText(templateFilePath, model, extensionPath, ramlDestFile, targetNamespace);
if (res.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, res.Errors);
MessageBox.Show(res.Errors);
return;
}
var content = TemplatesManager.AddClientMetadataHeader(res.Content);
var csTargetFile = Path.Combine(destFolderPath, destFolderName + ".cs");
File.WriteAllText(csTargetFile, content);
ramlProjItem.ProjectItems.AddFromFile(csTargetFile);
}
public async Task ShouldBuildArrayTypes()
{
var model = await GetArraysModel();
Assert.IsTrue(model.Objects.Any(o => o.Name == "ArrayOfObjectItem"));
Assert.IsTrue(model.Objects.Any(o => o.Name == "ArrayOfPerson"));
Assert.IsTrue(model.Objects.Any(o => o.Name == "ArrayOfInt"));
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("int"), model.Objects.First(o => o.Name == "ArrayOfInt").Type);
Assert.IsTrue(model.Objects.Any(o => o.Name == "ArrayOfObject"));
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("ArrayOfObjectItem"), model.Objects.First(o => o.Name == "ArrayOfObject").Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Objects.First(o => o.Name == "ArrayOfPerson").Type);
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Person"), model.Objects
.First(o => o.Name == "TypeThatHasArrayProperty")
.Properties
.First(p => p.Name == "Persons").Type);
Assert.AreEqual(6, model.Objects.Count());
}
private void AddOrUpdateModels(RamlChooserActionParams parameters, string contractsFolderPath, ProjectItem ramlItem, WebApiGeneratorModel model, ProjectItem contractsFolderItem, string extensionPath)
{
ThreadHelper.ThrowIfNotOnUIThread();
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, ModelTemplateName,
RAML.Tools.Properties.Settings.Default.ModelsTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var models = model.Objects;
// when is an XML model, skip empty objects
if (model.Objects.Any(o => !string.IsNullOrWhiteSpace(o.GeneratedCode)))
{
models = model.Objects.Where(o => o.Properties.Any() || !string.IsNullOrWhiteSpace(o.GeneratedCode));
}
// when array has no properties, set it collection on base type
foreach (var arrayModel in models.Where(o => o.IsArray && o.Properties.Count == 0 && o.Type != null &&
CollectionTypeHelper.IsCollection(o.Type) && !NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(o.Type))))
{
arrayModel.BaseClass = arrayModel.Type.Substring(1); // remove the initil "I" to make it a concrete class
}
// skip array of primitives
models = models.Where(o => o.Type == null || !(CollectionTypeHelper.IsCollection(o.Type) &&
NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(o.Type))));
models = models.Where(o => !o.IsScalar); // skip scalar types
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, ramlItem.FileNames[0]);
var apiObjectTemplateParams = new TemplateParams <ApiObject>(
Path.Combine(templatesFolder, ModelTemplateName), ramlItem, "apiObject", models,
contractsFolderPath, contractsFolderItem, extensionPath, parameters.ControllersNamespace,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion) +
(parameters.AddGeneratedSuffixToFiles ? ".generated" : string.Empty))
{
Title = RAML.Tools.Properties.Settings.Default.ModelsTemplateTitle,
RelativeFolder = parameters.ModelsFolder,
TargetFolder = TargetFolderResolver.GetModelsTargetFolder(ramlItem.ContainingProject,
targetFolderPath, parameters.ModelsFolder),
ModelsNamespace = parameters.ModelsNamespace
};
codeGenerator.GenerateCodeFromTemplate(apiObjectTemplateParams);
}
private void AddGeneratedMethod(Resource resource, string url, string objectName, Method method, ICollection <string> methodsNames,
ICollection <ClientGeneratorMethod> generatorMethods, IDictionary <string, Parameter> parentUriParameters)
{
var generatedMethod = BuildClassMethod(url, method, resource);
if (generatedMethod.ReturnType != "string")
{
var returnType = CollectionTypeHelper.GetBaseType(generatedMethod.ReturnType);
var returnTypeObject = schemaObjects.Values.Any(o => o.Name == returnType)
? schemaObjects.Values.First(o => o.Name == returnType)
: schemaResponseObjects.Values.FirstOrDefault(o => o.Name == returnType);
if (returnTypeObject != null)
{
generatedMethod.ReturnTypeObject = returnTypeObject;
generatedMethod.OkReturnType = GetOkReturnType(generatedMethod);
}
}
uriParametersGenerator.Generate(resource, url, generatedMethod, uriParameterObjects, parentUriParameters);
if (!IsVerbForMethod(method))
{
return;
}
if (methodsNames.Contains(generatedMethod.Name))
{
generatedMethod.Name = GetUniqueName(methodsNames, generatedMethod.Name, resource.RelativeUri);
}
GetQueryParameters(objectName, method, generatedMethod);
GetHeaders(objectName, method, generatedMethod);
GetResponseHeaders(objectName, generatedMethod, method);
generatorMethods.Add(generatedMethod);
methodsNames.Add(generatedMethod.Name);
}
public async Task ShouldParseArrays()
{
var model = await GetTestGeneratedModel();
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Sales"), model.Objects.First(o => o.Name == "GetSales").Properties[1].Type);
}
public async Task ShouldHandleArrayAsExpression()
{
var model = await BuildModel("files/raml1/array-type-expression.raml");
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("string"), model.Objects.First().Properties.First().Type);
}
public async Task ShouldParseArrays()
{
var model = await GetTestGeneratedModel();
Assert.AreEqual(CollectionTypeHelper.GetCollectionType("Sales"), model.ResponseObjects["/sales-getOKResponseContent"].Properties[1].Type);
}
public void should_clean_objects_not_used_as_return_types_client()
{
var property = new Property
{
Name = "Prop1",
Type = CollectionTypeHelper.GetCollectionType("Object2"),
OriginalName = "prop1"
};
var property2 = new Property
{
Name = "Prop2",
Type = "int",
OriginalName = "prop1"
};
var o1 = new ApiObject
{
Name = "Object1",
Properties = new[] { property }
};
var o2 = new ApiObject
{
Name = "Object2",
IsArray = true,
Properties = new[] { property2 }
};
var o3 = new ApiObject
{
Name = "Object3",
IsArray = true,
Properties = new[] { property }
};
var schemaResponseObjects = new Dictionary <string, ApiObject>();
schemaResponseObjects.Add("obj1", o1);
schemaResponseObjects.Add("obj2", o2);
schemaResponseObjects.Add("obj3", o3);
var schemaRequestObjects = new Dictionary <string, ApiObject>();
var cleaner = new ApiObjectsCleaner(schemaRequestObjects, schemaResponseObjects, new Dictionary <string, ApiObject>());
var classObjects = new List <ClassObject>();
var methods = new Collection <ClientGeneratorMethod>
{
new ClientGeneratorMethod
{
ReturnType = CollectionTypeHelper.GetCollectionType("Object1")
}
};
classObjects.Add(new ClassObject
{
Name = "Class1",
Methods = methods
});
cleaner.CleanObjects(classObjects, schemaResponseObjects, cleaner.IsUsedAsResponseInAnyMethod);
Assert.AreEqual(2, schemaResponseObjects.Count);
Assert.IsTrue(schemaResponseObjects.ContainsKey("obj1"));
Assert.IsTrue(schemaResponseObjects.ContainsKey("obj2"));
Assert.IsFalse(schemaResponseObjects.ContainsKey("obj3"));
}
