public void ShouldSerializeArrayRamlType()
{
var ramlTypesOrderedDictionary = new RamlTypesOrderedDictionary();
ramlTypesOrderedDictionary.Add("Person", new RamlType
{
Object = new ObjectType
{
Properties = new Dictionary<string, RamlType>()
{
{"firstname", new RamlType { Type = "string"}},
{"lastname", new RamlType { Type = "string", Required = true }}
}
}
});
ramlTypesOrderedDictionary.Add("Persons", new RamlType
{
Array = new ArrayType
{
Items = new RamlType
{
Type = "Person"
}
}
});
var doc = new RamlDocument
{
Types = ramlTypesOrderedDictionary
};
var res = serializer.Serialize(doc);
Assert.IsTrue(res.Contains(" - Persons:" + Environment.NewLine));
Assert.IsTrue(res.Contains(" type: Person[]" + Environment.NewLine));
}
private static SecurityScheme GetSchemeWithType(RamlDocument ramlDocument, string type)
{
return ramlDocument.SecuritySchemes.First(x => x.Values.Any(y => y.Type.First().Key == type))
.Values
.First(y => y.Type.First().Key == type);
}
private IEnumerable<Property> GetSecurityParameters(RamlDocument ramlDocument, Method method)
{
var securityParams = new Collection<Property>();
if (ramlDocument.SecuritySchemes == null || !ramlDocument.SecuritySchemes.Any())
return securityParams;
if ((ramlDocument.SecuredBy == null || !ramlDocument.SecuredBy.Any())
&& (method.SecuredBy == null || !method.SecuredBy.Any()))
return securityParams;
var securedBy = method.SecuredBy != null && method.SecuredBy.Any() ? method.SecuredBy : ramlDocument.SecuredBy;
if (securedBy == null)
return securityParams;
var secured = securedBy.First();
var dic = ramlDocument.SecuritySchemes.FirstOrDefault(s => s.ContainsKey(secured));
if (dic == null)
return securityParams;
var descriptor = ramlDocument.SecuritySchemes.First(s => s.ContainsKey(secured))[secured].DescribedBy;
if (descriptor == null || descriptor.QueryParameters == null || !descriptor.QueryParameters.Any())
return securityParams;
return QueryParametersParser.ConvertParametersToProperties(descriptor.QueryParameters);
}
private void SetPreview(RamlDocument document)
{
Dispatcher.Invoke(() =>
{
try
{
ResourcesLabel.Text = GetResourcesPreview(document);
StopProgress();
btnOk.IsEnabled = true;
SetNamespace(RamlTempFilePath);
if (NetNamingMapper.HasIndalidChars(txtFileName.Text))
{
ShowErrorStopProgressAndDisableOk("The specied file name has invalid chars");
txtFileName.Focus();
}
}
catch (Exception ex)
{
ShowErrorStopProgressAndDisableOk("Error while parsing raml file. " + ex.Message);
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, VisualStudioAutomationHelper.GetExceptionInfo(ex));
}
});
}
protected MethodsGeneratorBase(RamlDocument raml, IDictionary<string, ApiObject> schemaResponseObjects,
IDictionary<string, ApiObject> schemaRequestObjects, IDictionary<string, string> linkKeysWithObjectNames)
{
this.raml = raml;
this.schemaResponseObjects = schemaResponseObjects;
this.schemaRequestObjects = schemaRequestObjects;
this.linkKeysWithObjectNames = linkKeysWithObjectNames;
}
private static bool AreOAuth2EndpointsDefined(RamlDocument ramlDocument)
{
return ramlDocument.SecuritySchemes
.Any(x => x.Values
.Any(y => y.Settings != null
&& !string.IsNullOrWhiteSpace(y.Settings.AuthorizationUri)
&& !string.IsNullOrWhiteSpace(y.Settings.AccessTokenUri)));
}
public void Should_Build_Uri_Parameters_From_Resources()
{
var doc = new RamlDocument { Title = "test" };
var uriParameters = new Dictionary<string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies/{token}/abc/{code}/asd/{extra}",
Methods = methods,
UriParameters = uriParameters
},
new Resource
{
RelativeUri = "/directors/{a}/abc/{b}{c}/asd/{d}",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test");
var model = service.BuildModel();
Assert.AreEqual(2, model.UriParameterObjects.Count);
var moviesUriParamObj = model.UriParameterObjects.First(o => o.Key.ToLowerInvariant().Contains("movies")).Value;
var directorsUriParamObj = model.UriParameterObjects.First(o => o.Key.ToLowerInvariant().Contains("directors")).Value;
Assert.AreEqual(3, moviesUriParamObj.Properties.Count);
Assert.AreEqual(4, directorsUriParamObj.Properties.Count);
}
public void should_build_uri_parameter_objects()
{
var doc = new RamlDocument { Title = "test" };
var uriParams = new Dictionary<string, Parameter>()
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
},
new Method
{
Verb = "post"
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies",
UriParameters = uriParams,
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test");
var model = service.BuildModel();
Assert.AreEqual(1, model.UriParameterObjects.Count);
Assert.AreEqual(2, model.UriParameterObjects.First().Value.Properties.Count);
Assert.IsTrue(model.Classes.First().Methods.All(m => m.UriParametersType == "MoviesUriParameters"));
Assert.AreEqual(1, model.Objects.Count());
}
public void should_keep_original_names()
{
var doc = new RamlDocument { Title = "test" };
var uriParams = new Dictionary<string, Parameter>()
{
{
"code-oneOne", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token_Two", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
},
new Method
{
Verb = "post"
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies",
UriParameters = uriParams,
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test");
var model = service.BuildModel();
Assert.AreEqual("code-oneOne", model.UriParameterObjects.First().Value.Properties.First(p => p.Name == "CodeoneOne").OriginalName);
Assert.AreEqual("token_Two", model.UriParameterObjects.First().Value.Properties.First(p => p.Name == "Token_Two").OriginalName);
}
public ClientMethodsGenerator(RamlDocument raml, IDictionary<string, ApiObject> schemaResponseObjects,
IDictionary<string, ApiObject> uriParameterObjects, IDictionary<string, ApiObject> queryObjects,
IDictionary<string, ApiObject> headerObjects, IDictionary<string, ApiObject> responseHeadersObjects,
IDictionary<string, ApiObject> schemaRequestObjects, IDictionary<string, string> linkKeysWithObjectNames)
: base(raml, schemaResponseObjects, schemaRequestObjects, linkKeysWithObjectNames)
{
this.uriParameterObjects = uriParameterObjects;
this.queryObjects = queryObjects;
this.headerObjects = headerObjects;
this.responseHeadersObjects = responseHeadersObjects;
}
public RamlDocWrapper(string ramlFilePath)
{
//MuleSoft Raml parser
var parser = new RamlParser();
try
{
ramlDocument = parser.LoadAsync(ramlFilePath).Result;
}
catch (AggregateException ae) //Exceptions received from assync RamlParser
{
throw ae.Flatten();
}
}
public string Serialize(RamlDocument ramlDocument)
{
var sb = new StringBuilder(ramlDocument.Resources.Count + ramlDocument.Resources.Sum(r => r.Resources.Count) * 20);
sb.AppendLine("#%RAML " + (ramlDocument.RamlVersion == RamlVersion.Version08 ? "0.8" : "1.0"));
RamlSerializerHelper.SerializeProperty(sb, "title", ramlDocument.Title);
RamlSerializerHelper.SerializeProperty(sb, "baseUri", ramlDocument.BaseUri);
RamlSerializerHelper.SerializeProperty(sb, "version", ramlDocument.Version);
RamlSerializerHelper.SerializeProperty(sb, "mediaType", ramlDocument.MediaType);
SerializeArrayProperty(sb, "securedBy", ramlDocument.SecuredBy);
SerializeProtocols(sb, ramlDocument.Protocols);
SerializeParameters(sb, "uriParameters", ramlDocument.BaseUriParameters);
if (ramlDocument.Documentation.Any())
{
sb.AppendLine("documentation:");
foreach (var docItem in ramlDocument.Documentation)
{
RamlSerializerHelper.SerializeProperty(sb, "- title", docItem.Title, 2);
RamlSerializerHelper.SerializeMultilineProperty(sb, "content", docItem.Content, 4);
raml1TypesSerializer.SerializeAnnotations(sb, docItem.Annotations, 4);
}
sb.AppendLine();
}
SerializeSecuritySchemes(sb, ramlDocument.SecuritySchemes);
raml1TypesSerializer.Serialize(sb, ramlDocument.Types);
SerializeSchemas(sb, ramlDocument.Schemas);
SerializeResources(sb, ramlDocument.Resources);
SerializeAnnotationTypes(sb, ramlDocument.AnnotationTypes);
raml1TypesSerializer.SerializeAnnotations(sb, ramlDocument.Annotations);
return sb.ToString();
}
public RamlDocument Build(IDictionary<string, object> dynamicRaml)
{
var doc = new RamlDocument(dynamicRaml);
doc.BaseUri = (string) dynamicRaml["baseUri"];
doc.Title = (string)dynamicRaml["title"];
doc.Version = dynamicRaml.ContainsKey("version") ? (string)dynamicRaml["version"] : null;
doc.MediaType = dynamicRaml.ContainsKey("mediaType") ? (string)dynamicRaml["mediaType"] : null;
doc.Documentation = GetDocumentation(dynamicRaml);
doc.BaseUriParameters = ParametersBuilder.GetUriParameters(dynamicRaml, "baseUriParameters");
doc.SecuredBy = GetSecuredBy(dynamicRaml);
doc.Method = dynamicRaml.ContainsKey("method") ? (string)dynamicRaml["method"] : null;
doc.Protocols = ProtocolsBuilder.Get(dynamicRaml);
doc.SecuritySchemes = GetSecuritySchemes(dynamicRaml);
doc.ResourceTypes = GetResourceTypes(dynamicRaml);
doc.Traits = GetTraits(dynamicRaml);
doc.Schemas = GetSchemas(dynamicRaml);
doc.Resources = GetResources(dynamicRaml);
return doc;
}
public static Security GetSecurity(RamlDocument ramlDocument)
{
if (ramlDocument.SecuritySchemes == null || !ramlDocument.SecuritySchemes.Any())
return null;
SecurityScheme securityScheme = null;
if (IsTypeDefined(ramlDocument, OAuth2Type))
{
securityScheme = GetSchemeWithType(ramlDocument, OAuth2Type);
}
else if (AreOAuth2EndpointsDefined(ramlDocument))
{
securityScheme = GetSchemeWithOAuth2EndpointsDefined(ramlDocument);
}
else if (IsTypeDefined(ramlDocument, OAuth1Type))
{
securityScheme = GetSchemeWithType(ramlDocument, OAuth1Type);
}
if (securityScheme == null || (securityScheme.Settings == null && securityScheme.DescribedBy == null))
return new Security();
var settings = securityScheme.Settings;
var schemeDescriptor = securityScheme.DescribedBy;
return new Security
{
AccessTokenUri = settings == null ? null : settings.AccessTokenUri,
AuthorizationGrants = settings == null ? null : settings.AuthorizationGrants,
AuthorizationUri = settings == null ? null : settings.AuthorizationUri,
Scopes = settings == null ? null : settings.Scopes,
RequestTokenUri = settings == null ? null : settings.RequestTokenUri,
TokenCredentialsUri = settings == null ? null : settings.TokenCredentialsUri,
Headers = schemeDescriptor == null || schemeDescriptor.Headers == null
? new List<GeneratorParameter>()
: ParametersMapper.Map(schemeDescriptor.Headers),
QueryParameters = schemeDescriptor == null || schemeDescriptor.QueryParameters == null
? new List<GeneratorParameter>()
: ParametersMapper.Map(schemeDescriptor.QueryParameters)
};
}
public void Should_Generate_One_Method_Per_Verb()
{
var methods = new List<Method>
{
new Method
{
Verb = "get"
},
new Method
{
Verb = "post"
}
};
var resource = new Resource
{
RelativeUri = "/abc{token}{code}",
Methods = methods,
};
var schemaResponseObjects = new Dictionary<string, ApiObject>();
var schemaRequestObjects = new Dictionary<string, ApiObject>();
var ramlDocument = new RamlDocument();
var uriParameterObjects = new Dictionary<string, ApiObject>();
var queryObjects = new Dictionary<string, ApiObject>();
var headerObjects = new Dictionary<string, ApiObject>();
var responseHeadersObjects = new Dictionary<string, ApiObject>();
var linkedKeyWithObjectNames = new Dictionary<string, string>();
var classObject = new ClassObject();
var schemaObjects = new Dictionary<string, ApiObject>();
var generator = new ClientMethodsGenerator(ramlDocument, schemaResponseObjects,
uriParameterObjects, queryObjects, headerObjects, responseHeadersObjects, schemaRequestObjects, linkedKeyWithObjectNames,
schemaObjects);
var generatorMethods = generator.GetMethods(resource, "/", classObject, "Test", new Dictionary<string, Parameter>());
Assert.AreEqual(2, generatorMethods.Count);
}
private void OrganizeResourcesHierarchically(RamlDocument raml, Dictionary<string, Resource> resourcesDic)
{
foreach (var kv in resourcesDic)
{
var matchingResources = resourcesDic.Where(r => r.Key != kv.Key && kv.Key.StartsWith(r.Key + "/"));
if (matchingResources.Any())
{
var parent = matchingResources.OrderByDescending(r => r.Key.Length).First();
kv.Value.RelativeUri = kv.Value.RelativeUri.Substring(parent.Key.Length); // remove parent route from relative uri
parent.Value.Resources.Add(kv.Value);
}
else
{
raml.Resources.Add(kv.Value);
}
}
}
private void SetSecurityScheme(RamlDocument raml)
{
var securitySchemes = new List<IDictionary<string, SecurityScheme>>();
if (raml.SecuritySchemes != null && raml.SecuritySchemes.Any())
securitySchemes = raml.SecuritySchemes.ToList();
var schemes = new Dictionary<string, SecurityScheme> { { securityType, securityScheme } };
securitySchemes.Add(schemes);
raml.SecuritySchemes = securitySchemes;
}
public WebApiGeneratorService(RamlDocument raml) : base(raml)
{
}
protected GeneratorServiceBase(RamlDocument raml, string targetNamespace)
{
this.raml = raml;
this.targetNamespace = targetNamespace;
apiObjectsCleaner = new ApiObjectsCleaner(schemaRequestObjects, schemaResponseObjects, schemaObjects);
}
public WebApiMethodsGenerator(RamlDocument raml, IDictionary<string, ApiObject> schemaResponseObjects,
IDictionary<string, ApiObject> schemaRequestObjects, IDictionary<string, string> linkKeysWithObjectNames)
: base(raml, schemaResponseObjects, schemaRequestObjects, linkKeysWithObjectNames)
{
}
public void Should_Inherit_Uri_Parameters_When_Nested_Resources_ClientCase2()
{
var doc = new RamlDocument { Title = "test" };
var uriParameters1 = new Dictionary<string, Parameter>
{
{
"id", new Parameter
{
DisplayName = "id",
Type = "integer"
}
}
};
var uriParameters2 = new Dictionary<string, Parameter>
{
{
"current", new Parameter
{
DisplayName = "current",
Type = "boolean"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/{id}",
Methods = methods,
UriParameters = uriParameters1,
Resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/something",
Methods = methods,
Resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/{current}",
Methods = methods,
UriParameters = uriParameters2,
Resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/deep",
Methods = methods
}
}
}
}
}
}
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TargetNamespace");
var model = service.BuildModel();
Assert.AreEqual("bool", model.Classes.First(m => m.Name.Contains("Deep")).Methods.First().UriParameters.First(p => p.Name == "current").Type);
Assert.AreEqual("int", model.Classes.First(m => m.Name.Contains("Deep")).Methods.First().UriParameters.First(p => p.Name == "id").Type);
}
private static bool IsTypeDefined(RamlDocument ramlDocument, string type)
{
return ramlDocument.SecuritySchemes.Any(x => x.Values.Any(y => y.Type.First().Key == type));
}
public void Should_Build_Uri_Parameters_When_Nested_Resources()
{
var doc = new RamlDocument { Title = "test" };
var uriParameters = new Dictionary<string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies/{token}{extra}/abc/{code}{extra}/asd",
Methods = methods,
UriParameters = uriParameters,
Resources = new[]
{
new Resource
{
RelativeUri = "/{a}{b}",
Methods = methods
}
}
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test");
var model = service.BuildModel();
Assert.AreEqual(2, model.UriParameterObjects.Count);
var moviesUriParamObj = model.UriParameterObjects.First().Value;
var directorsUriParamObj = model.UriParameterObjects.Last().Value;
Assert.AreEqual(3, moviesUriParamObj.Properties.Count);
Assert.AreEqual(5, directorsUriParamObj.Properties.Count);
}
public ClientGeneratorService(RamlDocument raml, string rootClassName)
: base(raml)
{
this.rootClassName = rootClassName;
}
public void Should_Get_Multiple_Type_When_Many_Response_Schemas_On_Resource()
{
var doc = new RamlDocument { Title = "test" };
var okResponse = new Response
{
Code = "200",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = movieSchema
}
}
}
};
var errorResponse = new Response
{
Code = "400",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = errorSchema
}
}
}
};
var notFoundResponse = new Response
{
Code = "404",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = notFoundSchema
}
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual(4, model.ResponseObjects.Count);
var multipleModel = model.ResponseObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
}
protected GeneratorServiceBase(RamlDocument raml)
{
this.raml = raml;
apiObjectsCleaner = new ApiObjectsCleaner(schemaRequestObjects, schemaResponseObjects);
}
public RamlDocument GetRaml(string title = null)
{
if (string.IsNullOrWhiteSpace(title))
title = "Api";
var raml = new RamlDocument {Title = title, BaseUri = baseUri};
var resourcesDic = new Dictionary<string, Resource>();
var parameterDescriptionsDic = new Dictionary<string, Collection<ApiParameterDescription>>();
foreach (var api in apiExplorer.ApiDescriptions)
{
var relativeUri = !api.Route.RouteTemplate.StartsWith("/") ? "/" + api.Route.RouteTemplate : api.Route.RouteTemplate;
if (relativeUri.Contains("{controller}"))
{
relativeUri = relativeUri.Replace("{controller}", api.ActionDescriptor.ControllerDescriptor.ControllerName);
if (relativeUri.EndsWith("/"))
relativeUri = relativeUri.Substring(0, relativeUri.Length - 1);
}
foreach (var apiParam in GetParametersFromUrl(relativeUri))
{
relativeUri = RemoveNonExistingParametersFromRoute(relativeUri, api, apiParam.Key);
}
Resource resource;
if (!resourcesDic.ContainsKey(relativeUri))
{
resource = new Resource
{
Methods = GetMethods(api, new Collection<string>()),
RelativeUri = relativeUri,
};
parameterDescriptionsDic.Add(relativeUri, api.ParameterDescriptions);
resourcesDic.Add(relativeUri, resource);
}
else
{
resource = resourcesDic[relativeUri];
foreach (var apiParameterDescription in api.ParameterDescriptions)
{
parameterDescriptionsDic[relativeUri].Add(apiParameterDescription);
}
AddMethods(resource, api, resource.Methods.Select(m => m.Verb).ToList());
}
if(SetResourceProperties != null)
SetResourceProperties(resource, api);
if(SetResourcePropertiesByAction != null)
SetResourcePropertiesByAction(resource, api.ActionDescriptor);
if(SetResourcePropertiesByController != null)
SetResourcePropertiesByController(resource, api.ActionDescriptor.ControllerDescriptor);
}
raml.Schemas = new List<IDictionary<string, string>> { schemas };
OrganizeResourcesHierarchically(raml, resourcesDic);
SetUriParameters(raml.Resources, parameterDescriptionsDic, string.Empty);
if(SetRamlProperties != null)
SetRamlProperties(raml);
if (SecuritySchemes != null)
raml.SecuritySchemes = SecuritySchemes;
if (!string.IsNullOrWhiteSpace(securityType) && securityScheme != null)
SetSecurityScheme(raml);
if (SecuredBy != null)
raml.SecuredBy = SecuredBy;
if(Protocols != null)
raml.Protocols = Protocols;
return raml;
}
private static string GetResourcesPreview(RamlDocument ramlDoc)
{
return GetChildResources(ramlDoc.Resources, 0);
}
public void Should_Build_Multiple_Headers_When_Many_Response_With_Headers()
{
var doc = new RamlDocument {Title = "test"};
var okHeaders = new List<Parameter>
{
new Parameter
{
DisplayName = "code",
Type = "integer"
},
new Parameter
{
DisplayName = "token",
Type = "string"
}
};
var errorHeaders = new List<Parameter>
{
new Parameter
{
DisplayName = "code",
Type = "integer"
},
new Parameter
{
DisplayName = "error",
Type = "string"
}
};
var badRequestHeaders = new List<Parameter>
{
new Parameter
{
DisplayName = "code",
Type = "integer"
},
new Parameter
{
DisplayName = "description",
Type = "string"
}
};
var okResponse = new Response
{
Code = "200",
Headers = okHeaders
};
var errorResponse = new Response
{
Code = "400",
Headers = errorHeaders
};
var notFoundResponse = new Response
{
Code = "404",
Headers = badRequestHeaders
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TargetNamespace");
var model = service.BuildModel();
Assert.AreEqual(4, model.ResponseHeaderObjects.Count);
var multipleModel = model.ResponseHeaderObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
Assert.AreEqual("Models." + model.ResponseHeaderObjects.First(o => o.Key.Contains("Multiple")).Value.Name,
model.Classes.First().Methods.First().ResponseHeaderType);
}
public void Should_Get_Multiple_Type_When_Many_Response_Schemas_On_Root()
{
var doc = new RamlDocument {Title = "test"};
var schemas = new List<Dictionary<string, string>>();
var schemaMovie = new Dictionary<string, string>();
schemaMovie.Add("movie", movieSchema);
var schemaError = new Dictionary<string, string>();
schemaMovie.Add("error", errorSchema);
var schemaNotFound = new Dictionary<string, string>();
schemaMovie.Add("notfound", notFoundSchema);
schemas.Add(schemaMovie);
schemas.Add(schemaError);
schemas.Add(schemaNotFound);
doc.Schemas = schemas;
var okResponse = new Response
{
Code = "200",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "movie"
}
}
}
};
var errorResponse = new Response
{
Code = "400",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "error"
}
}
}
};
var notFoundResponse = new Response
{
Code = "404",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "notfound"
}
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual(1, model.ResponseObjects.Count);
Assert.AreEqual(3, model.SchemaObjects.Count);
var multipleModel = model.ResponseObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Movie"));
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Error"));
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Notfound"));
}
