public void TestParameterLocationExtension()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-parameter-location.json"),
PayloadFlatteningThreshold = 3
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal(clientModel.Properties[0].Name, "SubscriptionId");
Assert.Equal(clientModel.Properties[1].Name, "ApiVersion");
Assert.False(
clientModel.Methods[0].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
Assert.False(
clientModel.Methods[1].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
}
}
/// <summary>
/// Normalizes client model using Azure-specific extensions.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <param name="codeNamer">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeAzureClientModel(ServiceClient serviceClient, Settings settings, CodeNamer codeNamer)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (codeNamer == null)
{
throw new ArgumentNullException("codeNamer");
}
settings.AddCredentials = true;
// This extension from general extensions must be run prior to Azure specific extensions.
ProcessParameterizedHost(serviceClient, settings);
ProcessClientRequestIdExtension(serviceClient);
UpdateHeadMethods(serviceClient);
ParseODataExtension(serviceClient);
ProcessGlobalParameters(serviceClient);
FlattenModels(serviceClient);
FlattenMethodParameters(serviceClient, settings);
ParameterGroupExtensionHelper.AddParameterGroups(serviceClient);
AddLongRunningOperations(serviceClient);
AddAzureProperties(serviceClient);
SetDefaultResponses(serviceClient);
AddPageableMethod(serviceClient, codeNamer);
}
/// <summary>
/// Initializes a new instance of the class RubyCodeGenerator.
/// </summary>
/// <param name="settings">The settings.</param>
public RubyCodeGenerator(Settings settings) : base(settings)
{
CodeNamer = new RubyCodeNamer();
this.packageVersion = Settings.PackageVersion;
this.packageName = Settings.PackageName;
if (Settings.CustomSettings.ContainsKey("Name"))
{
this.sdkName = Settings.CustomSettings["Name"].ToString();
}
if (sdkName == null)
{
this.sdkName = Path.GetFileNameWithoutExtension(Settings.Input);
}
if (sdkName == null)
{
sdkName = "client";
}
this.sdkName = RubyCodeNamer.UnderscoreCase(CodeNamer.RubyRemoveInvalidCharacters(this.sdkName));
this.sdkPath = this.packageName ?? this.sdkName;
this.modelsPath = Path.Combine(this.sdkPath, "models");
// AutoRest generated code for Ruby and Azure.Ruby generator will live inside "generated" sub-folder
settings.OutputDirectory = Path.Combine(settings.OutputDirectory, GeneratedFolderName);
}
private static async Task TestGenerate(string apiVersion, string[] methodUrls, string expectedJsonString)
{
using (NewContext) {
MemoryFileSystem fileSystem = new MemoryFileSystem();
Settings settings = new Settings();
settings.FileSystem = fileSystem;
CodeModel serviceClient = New<CodeModel>();
serviceClient.ApiVersion = apiVersion;
foreach (string methodUrl in methodUrls) {
serviceClient.Add(New<Method>(new {
Url = methodUrl,
HttpMethod = HttpMethod.Put,
}));
}
await CreatePlugin().CodeGenerator.Generate(serviceClient);
Assert.Equal(2, fileSystem.VirtualStore.Count);
string folderPath = fileSystem.VirtualStore.Keys.First();
Assert.Equal("Folder", fileSystem.VirtualStore[folderPath].ToString());
JObject expectedJSON = JObject.Parse(expectedJsonString);
string fileContents = fileSystem.VirtualStore[fileSystem.VirtualStore.Keys.Skip(1).First()].ToString();
JObject actualJson = JObject.Parse(fileContents);
Assert.Equal(expectedJSON, actualJson);
}
}
public AzurePythonCodeGenerator(Settings settings)
: base(settings)
{
pageModels = new List<PageTemplateModel>();
pageClasses = new Dictionary<string, IDictionary<int, string>>();
Namer = new AzurePythonCodeNamer();
}
public void TestInputMapping()
{
using (NewContext)
{
var settings = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-payload-flatten.json"),
PayloadFlatteningThreshold = 3,
OutputDirectory = Path.GetTempPath()
};
settings.FileSystem = new MemoryFileSystem();
settings.FileSystem.WriteFile("AutoRest.json", File.ReadAllText("AutoRest.json"));
settings.FileSystem.CreateDirectory(Path.GetDirectoryName(settings.Input));
settings.FileSystem.WriteFile(settings.Input, File.ReadAllText(settings.Input));
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
CodeGeneratorCs generator = new CodeGeneratorCs();
generator.Generate(clientModel).GetAwaiter().GetResult();
string body = settings.FileSystem.ReadFileAsText(Path.Combine(settings.OutputDirectory, "Payload.cs"));
Assert.True(body.ContainsMultiline(@"
MinProduct minProduct = new MinProduct();
if (baseProductId != null || baseProductDescription != null || maxProductReference != null)
{
minProduct.BaseProductId = baseProductId;
minProduct.BaseProductDescription = baseProductDescription;
minProduct.MaxProductReference = maxProductReference;
}"));
}
}
public void ConvertsPageResultsToPageTypeTest()
{
var settings = new Settings
{
Input = Path.Combine("Swagger", "azure-paging.json")
};
var modeler = new SwaggerModeler(settings);
var serviceClient = modeler.Build();
var codeGen = new AzureCSharpCodeGenerator(settings);
codeGen.NormalizeClientModel(serviceClient);
Assert.Equal(7, serviceClient.Methods.Count);
Assert.Equal(1, serviceClient.Methods.Count(m => m.Name == "GetSinglePage"));
Assert.Equal(0, serviceClient.Methods.Count(m => m.Name == "GetSinglePageNext"));
Assert.Equal(1, serviceClient.Methods.Count(m => m.Name == "PutSinglePage"));
Assert.Equal(1, serviceClient.Methods.Count(m => m.Name == "PutSinglePageSpecialNext"));
Assert.Equal("Page<Product>", serviceClient.Methods[0].ReturnType.Body.Name);
Assert.Equal("object", serviceClient.Methods[1].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", serviceClient.Methods[1].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("string", serviceClient.Methods[1].Responses.ElementAt(1).Value.Body.Name.ToLowerInvariant());
Assert.Equal("object", serviceClient.Methods[2].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", serviceClient.Methods[2].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<Product>", serviceClient.Methods[2].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal("object", serviceClient.Methods[3].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", serviceClient.Methods[3].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<ProductChild>", serviceClient.Methods[3].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal(5, serviceClient.ModelTypes.Count);
Assert.False(serviceClient.ModelTypes.Any(t => t.Name.Equals("ProducResult", StringComparison.OrdinalIgnoreCase)));
Assert.False(serviceClient.ModelTypes.Any(t => t.Name.Equals("ProducResult2", StringComparison.OrdinalIgnoreCase)));
Assert.False(serviceClient.ModelTypes.Any(t => t.Name.Equals("ProducResult3", StringComparison.OrdinalIgnoreCase)));
}
public void TestClientModelWithPayloadFlattening()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-payload-flatten.json"),
PayloadFlatteningThreshold = 3
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(4, clientModel.Methods[0].Parameters.Count);
Assert.Equal("String subscriptionId", clientModel.Methods[0].Parameters[0].ToString());
Assert.Equal("String resourceGroupName", clientModel.Methods[0].Parameters[1].ToString());
Assert.Equal("String apiVersion", clientModel.Methods[0].Parameters[2].ToString());
Assert.Equal("MaxProduct maxProduct", clientModel.Methods[0].Parameters[3].ToString());
Assert.Equal(6, clientModel.Methods[1].Parameters.Count);
Assert.Equal("String subscriptionId", clientModel.Methods[1].Parameters[0].ToString());
Assert.Equal("String resourceGroupName", clientModel.Methods[1].Parameters[1].ToString());
Assert.Equal("String apiVersion", clientModel.Methods[1].Parameters[2].ToString());
Assert.Equal("String baseProductId", clientModel.Methods[1].Parameters[3].ToString());
Assert.Equal(true, clientModel.Methods[1].Parameters[3].IsRequired);
Assert.Equal("String baseProductDescription", clientModel.Methods[1].Parameters[4].ToString());
Assert.Equal(false, clientModel.Methods[1].Parameters[4].IsRequired);
Assert.Equal("MaxProduct maxProductReference", clientModel.Methods[1].Parameters[5].ToString());
Assert.Equal(false, clientModel.Methods[1].Parameters[5].IsRequired);
Assert.Equal(1, clientModel.Methods[1].InputParameterTransformation.Count);
Assert.Equal(3, clientModel.Methods[1].InputParameterTransformation[0].ParameterMappings.Count);
}
}
public AzureCSharpFluentCodeNamer(Settings settings)
:base(settings)
{
_innerTypes = new HashSet<CompositeType>();
_resourceType = new CompositeType
{
Name = "Microsoft.Rest.Azure.Resource",
SerializedName = "Resource",
};
var stringType = new PrimaryType(KnownPrimaryType.String)
{
Name = "string"
};
_resourceType.Properties.Add(new Property { Name = "location", SerializedName = "location", Type = stringType });
_resourceType.Properties.Add(new Property { Name = "id", SerializedName = "id", Type = stringType });
_resourceType.Properties.Add(new Property { Name = "name", SerializedName = "name", Type = stringType });
_resourceType.Properties.Add(new Property { Name = "type", SerializedName = "type", Type = stringType });
_resourceType.Properties.Add(new Property { Name = "tags", SerializedName = "tags", Type = new DictionaryType { ValueType = stringType, NameFormat = "System.Collections.Generic.IDictionary<string, {0}>" } });
_subResourceType = new CompositeType
{
Name = "Microsoft.Rest.Azure.SubResource",
SerializedName = "SubResource"
};
_subResourceType.Properties.Add(new Property { Name = "id", SerializedName = "id", Type = stringType });
}
/// <summary>
/// Normalizes client model using Azure-specific extensions.
/// </summary>
/// <param name="codeModelient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <param name="codeNamer">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeAzureClientModel(CodeModel codeModel)
{
var settings = Settings.Instance;
using (NewContext)
{
settings = new Settings().LoadFrom(settings);
settings.AddCredentials = true;
if (codeModel == null)
{
throw new ArgumentNullException("codeModel");
}
// This extension from general extensions must be run prior to Azure specific extensions.
ProcessParameterizedHost(codeModel);
ProcessClientRequestIdExtension(codeModel);
UpdateHeadMethods(codeModel);
ParseODataExtension(codeModel);
ProcessGlobalParameters(codeModel);
FlattenModels(codeModel);
FlattenMethodParameters(codeModel);
ParameterGroupExtensionHelper.AddParameterGroups(codeModel);
AddLongRunningOperations(codeModel);
AddAzureProperties(codeModel);
SetDefaultResponses(codeModel);
AddPageableMethod(codeModel);
}
}
/// <summary>
/// Normalizes client model using generic extensions.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeClientModel(ServiceClient serviceClient, Settings settings)
{
ProcessGlobalParameters(serviceClient);
FlattenModels(serviceClient);
FlattenMethodParameters(serviceClient, settings);
ParameterGroupExtensionHelper.AddParameterGroups(serviceClient);
ProcessParameterizedHost(serviceClient, settings);
}
public async Task SupportModelsNameOverride()
{
string modelsName = "MyModels";
MemoryFileSystem fileSystem = CreateMockFilesystem();
var settings = new Settings
{
Modeler = "Swagger",
CodeGenerator = "CSharp",
FileSystem = fileSystem,
OutputDirectory = "GeneratedCode",
Namespace = "Test",
ModelsName = modelsName
};
using (fileSystem = $"{GetType().Name}.yaml".GenerateCodeInto(fileSystem, settings))
{
// Expected Files
Assert.True(fileSystem.FileExists($@"{settings.OutputDirectory}\{modelsName}\ResultObject.cs"));
var result = await Compile(fileSystem);
// filter the warnings
var warnings = result.Messages.Where(
each => each.Severity == DiagnosticSeverity.Warning
&& !SuppressWarnings.Contains(each.Id)).ToArray();
// use this to dump the files to disk for examination
// fileSystem.SaveFilesToTemp($"{GetType().Name}");
// filter the errors
var errors = result.Messages.Where(each => each.Severity == DiagnosticSeverity.Error).ToArray();
Write(warnings, fileSystem);
Write(errors, fileSystem);
// use this to write out all the messages, even hidden ones.
// Write(result.Messages, fileSystem);
// Don't proceed unless we have zero Warnings.
Assert.Empty(warnings);
// Don't proceed unless we have zero Errors.
Assert.Empty(errors);
// Should also succeed.
Assert.True(result.Succeeded);
// try to load the assembly
var asm = Assembly.Load(result.Output.GetBuffer());
Assert.NotNull(asm);
// verify that we have the class we expected
var resultObject = asm.ExportedTypes.FirstOrDefault(each => each.FullName == $"Test.{modelsName}.ResultObject");
Assert.NotNull(resultObject);
}
}
public SwaggerModeler(Settings settings) : base(settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
DefaultProtocol = TransferProtocolScheme.Http;
}
public void UsageInstructionsWithOutputFileSetting()
{
Settings settings = new Settings()
{
OutputFileName = "spam.json"
};
AzureResourceSchemaCodeGenerator codeGen = CreateGenerator(settings);
Assert.Equal("Your Azure Resource Schema(s) can be found in " + settings.OutputDirectory, codeGen.UsageInstructions);
}
public void UsageInstructionsWithOutputFileSetting()
{
using (NewContext) {
Settings settings = new Settings() {
OutputFileName = "spam.json"
};
PluginArs plugin = CreatePlugin();
Assert.Equal("Your Azure Resource Schema(s) can be found in " + settings.OutputDirectory, plugin.CodeGenerator.UsageInstructions);
}
}
public void TestClientModelWithPayloadFlatteningViaXMSClientFlatten()
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-flatten.json")
};
var modeler = new SwaggerModeler(setting);
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel, setting);
Assert.NotNull(clientModel);
Assert.Equal(8, clientModel.ModelTypes.Count);
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "SimpleProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProductProperties")); // Since it's referenced in the response
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "RecursiveProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "Error"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ProductWithInheritance"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseFlattenedProduct"));
var simpleProduct = clientModel.ModelTypes.First(m => m.Name == "SimpleProduct");
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name"
&& p.Name == "max_product_display_name"));
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_capacity"
&& p.Name == "max_product_capacity"));
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_image.@odata\\\\.value"
&& p.Name == "@odata.value"));
var conflictedProduct = clientModel.ModelTypes.First(m => m.Name == "ConflictedProduct");
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "max_product_display_name"
&& p.Name == "max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name"
&& p.Name == "ConflictedProductProperties_max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "simpleDetails.max_product_display_name"
&& p.Name == "SimpleProductProperties_max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.base_product_description"
&& p.Name == "ConflictedProduct_base_product_description"));
var recursiveProduct = clientModel.ModelTypes.First(m => m.Name == "RecursiveProduct");
Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.name"
&& p.Name == "name"));
Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.parent"
&& p.Name == "parent"));
var error = clientModel.ModelTypes.First(m => m.Name == "Error");
Assert.Equal(3, error.Properties.Count);
Assert.True(error.Properties.Any(p => p.SerializedName == "code" && p.Name == "code"));
Assert.True(error.Properties.Any(p => p.SerializedName == "message" && p.Name == "message"));
Assert.True(error.Properties.Any(p => p.SerializedName == "parentError" && p.Name == "parentError"));
Assert.True(error.Properties.First(p => p.SerializedName == "parentError" && p.Name == "parentError").Type == error);
}
internal static MemoryFileSystem GenerateCodeInto(this string inputFile, MemoryFileSystem fileSystem)
{
var settings = new Settings
{
Modeler = "Swagger",
CodeGenerator = "CSharp",
FileSystem = fileSystem,
OutputDirectory = "GeneratedCode",
Namespace = "Test"
};
return inputFile.GenerateCodeInto(fileSystem, settings);
}
internal static MemoryFileSystem GenerateCodeInto(this string inputFile, MemoryFileSystem fileSystem, Settings settings)
{
string fileName = Path.GetFileName(inputFile);
// If inputFile does not contain a path use the local Resource folder
if (inputFile == fileName)
{
fileSystem.Copy(Path.Combine("Resource", inputFile));
}
else
{
fileSystem.Copy(inputFile);
}
settings.Input = fileName;
var plugin = ExtensionsLoader.GetPlugin();
var modeler = ExtensionsLoader.GetModeler();
var codeModel = modeler.Build();
// After swagger Parser
codeModel = AutoRestController.RunExtensions(Trigger.AfterModelCreation, codeModel);
// After swagger Parser
codeModel = AutoRestController.RunExtensions(Trigger.BeforeLoadingLanguageSpecificModel, codeModel);
using (plugin.Activate())
{
// load model into language-specific code model
codeModel = plugin.Serializer.Load(codeModel);
// we've loaded the model, run the extensions for after it's loaded
codeModel = AutoRestController.RunExtensions(Trigger.AfterLoadingLanguageSpecificModel, codeModel);
// apply language-specific tranformation (more than just language-specific types)
// used to be called "NormalizeClientModel" .
codeModel = plugin.Transformer.TransformCodeModel(codeModel);
// next set of extensions
codeModel = AutoRestController.RunExtensions(Trigger.AfterLanguageSpecificTransform, codeModel);
// next set of extensions
codeModel = AutoRestController.RunExtensions(Trigger.BeforeGeneratingCode, codeModel);
// Generate code from CodeModel.
plugin.CodeGenerator.Generate(codeModel).GetAwaiter().GetResult();
}
return fileSystem;
}
public static void RunTests(string specFile, string resultFolder, string modeler = "Swagger", string generator = "CSharp")
{
var settings = new Settings
{
Input = specFile,
OutputDirectory = "X:\\Output",
Header = "MICROSOFT_MIT_NO_VERSION",
Modeler = modeler,
CodeGenerator = generator,
PayloadFlatteningThreshold = 1
};
RunTests(settings, resultFolder);
}
internal static MemoryFileSystem GenerateCodeInto(this string inputDir, MemoryFileSystem fileSystem, string codeGenerator="CSharp", string modeler = "Swagger")
{
using (NewContext)
{
var settings = new Settings
{
Modeler = modeler,
CodeGenerator =codeGenerator,
FileSystem = fileSystem,
OutputDirectory = "GeneratedCode",
Namespace = "Test"
};
return inputDir.GenerateCodeInto(fileSystem, settings);
}
}
/// <summary>
/// Generates client using provided settings.
/// </summary>
/// <param name="settings">Code generator settings.</param>
public static void Generate(Settings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
Logger.Entries.Clear();
Logger.LogInfo(Resources.AutoRestCore, Version);
Modeler modeler = ExtensionsLoader.GetModeler(settings);
ServiceClient serviceClient = null;
IEnumerable<ValidationMessage> messages = new List<ValidationMessage>();
try
{
serviceClient = modeler.Build(out messages);
}
catch (Exception exception)
{
throw ErrorManager.CreateError(exception, Resources.ErrorGeneratingClientModel, exception.Message);
}
finally
{
// Make sure to log any validation messages
foreach (var message in messages)
{
Logger.Entries.Add(new LogEntry(message.Severity, message.ToString()));
}
if (messages.Any(entry => entry.Severity >= settings.ValidationLevel))
{
throw ErrorManager.CreateError(null, Resources.ErrorGeneratingClientModel, Resources.CodeGenerationError);
}
}
CodeGenerator codeGenerator = ExtensionsLoader.GetCodeGenerator(settings);
Logger.WriteOutput(codeGenerator.UsageInstructions);
settings.Validate();
try
{
codeGenerator.NormalizeClientModel(serviceClient);
codeGenerator.Generate(serviceClient).GetAwaiter().GetResult();
}
catch (Exception exception)
{
throw ErrorManager.CreateError(exception, Resources.ErrorSavingGeneratedCode, exception.Message);
}
}
public void ConvertsPageResultsToPageTypeTest()
{
using (NewContext)
{
var settings = new Settings
{
Input = Path.Combine("Swagger", "azure-paging.json")
};
var modeler = new SwaggerModeler();
var codeModel = modeler.Build();
var plugin = new PluginCsa();
using (plugin.Activate()) {
codeModel = plugin.Serializer.Load(codeModel);
codeModel = plugin.Transformer.TransformCodeModel(codeModel);
Assert.Equal(7, codeModel.Methods.Count);
Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "GetSinglePage"));
Assert.Equal(0, codeModel.Methods.Count(m => m.Name == "GetSinglePageNext"));
Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "PutSinglePage"));
Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "PutSinglePageSpecialNext"));
Assert.Equal("Page<Product>", codeModel.Methods[0].ReturnType.Body.Name);
Assert.Equal("object", codeModel.Methods[1].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", codeModel.Methods[1].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("string",
codeModel.Methods[1].Responses.ElementAt(1).Value.Body.Name.ToLowerInvariant());
Assert.Equal("object", codeModel.Methods[2].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", codeModel.Methods[2].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<Product>", codeModel.Methods[2].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal("object", codeModel.Methods[3].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", codeModel.Methods[3].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<ProductChild>", codeModel.Methods[3].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal(5, codeModel.ModelTypes.Count);
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult")));
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult2")));
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult3")));
}
}
}
/// <summary>
/// Helper method -- load two Swagger documents and invoke the comparison logic.
/// </summary>
/// <param name="input">The name of the swagger document file. The file name must be the same in both the 'modified' and 'original' folder.</param>
/// <returns>A list of messages from the comparison logic.</returns>
private IEnumerable<ComparisonMessage> CompareSwagger(string input)
{
using (NewContext)
{
var settings = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "Comparison", "Modified", input),
Previous = Path.Combine("Swagger", "Comparison", "Original", input)
};
var modeler = new SwaggerModeler();
IEnumerable<ComparisonMessage> messages = modeler.Compare();
// remove debug-level messages
messages = messages.Where(each => each.Severity > LogEntrySeverity.Debug);
return messages;
}
}
public AzureCSharpCodeNamer(Settings settings)
{
if (settings != null && settings.CustomSettings != null)
{
foreach (var setting in settings.CustomSettings.Keys)
{
if (setting.Equals("useDateTimeOffset", StringComparison.OrdinalIgnoreCase))
{
bool toUse;
if (bool.TryParse(settings.CustomSettings[setting].ToString(), out toUse))
{
UseDateTimeOffset = toUse;
}
else
{
UseDateTimeOffset = false;
}
}
}
}
}
public static void RunTests(Settings settings, string resultFolder)
{
// TODO: Run as process
//var virtualStore = new MemoryFileSystem();
//settings.FileSystem = virtualStore;
//settings.ApplicationConfigurationPath = Path.Combine((new FileSystem()).GetCurrentDirectory(),
// "../../../../binaries/net45/autorest.json");
//settings.FileSystem.WriteFile("AutoRest.json", File.ReadAllText("AutoRest.json"));
//settings.FileSystem.CreateDirectory(Path.GetDirectoryName(settings.Input));
//settings.FileSystem.WriteFile(settings.Input, File.ReadAllText(settings.Input));
//settings.FileSystem = new FileSystem();
//var flavor = ExtensionsLoader.GetCodeGenerator(settings);
//settings.FileSystem = virtualStore;
//var expectedWithSeparator = "Expected" + Path.DirectorySeparatorChar;
//var specFileName = resultFolder.StartsWith(expectedWithSeparator, StringComparison.Ordinal)
// ? resultFolder.Substring(expectedWithSeparator.Length)
// : resultFolder;
//settings.Namespace = string.IsNullOrEmpty(settings.Namespace)
// ? "Fixtures." + (flavor.Name.Contains("Azure") ? "Azure." : "") + specFileName.
// Replace(".cs", "").Replace(".Cs", "").Replace(".java", "").
// Replace(".js", "").Replace(".", "").
// Replace(Path.DirectorySeparatorChar.ToString(), "").Replace("-", "")
// : settings.Namespace;
//AutoRest.Generate(settings);
//Assert.NotEmpty(((MemoryFileSystem)settings.FileSystem).VirtualStore);
//var actualFiles = settings.FileSystem.GetFiles("X:\\Output", "*.*", true).OrderBy(f => f).ToArray();
//var expectedFiles = Directory.GetFiles(resultFolder, "*.*", SearchOption.AllDirectories).OrderBy(f => f).ToArray();
//Assert.Equal(expectedFiles.Length, actualFiles.Length);
//for (int i = 0; i < expectedFiles.Length; i++)
//{
// var actualFile = actualFiles[i];
// var expectedFile = expectedFiles[i];
// EnsureFilesMatch(File.ReadAllText(expectedFile), settings.FileSystem.ReadFileAsText(actualFile));
//}
}
public static MemoryFileSystem GenerateCodeForTest(string json, string codeGenerator, Action<IEnumerable<ValidationMessage>> processMessages)
{
using (NewContext)
{
var fs = new MemoryFileSystem();
var settings = new Settings
{
Modeler = "Swagger",
CodeGenerator = codeGenerator,
FileSystem = fs,
OutputDirectory = "GeneratedCode",
Namespace = "Test",
Input = "input.json"
};
fs.WriteFile(settings.Input, json);
fs.WriteFile("AutoRest.json", autoRestJson);
GenerateCodeInto(processMessages);
return fs;
}
}
internal static MemoryFileSystem GenerateCodeInto(this string inputFile, MemoryFileSystem fileSystem, Settings settings)
{
string fileName = Path.GetFileName(inputFile);
// If inputFile does not contain a path use the local Resource folder
if (inputFile == fileName)
{
fileSystem.Copy(Path.Combine("Resource", inputFile));
}
else
{
fileSystem.Copy(inputFile);
}
settings.Input = fileName;
var codeGenerator = new CSharpCodeGenerator(settings);
var modeler = ExtensionsLoader.GetModeler(settings);
var sc = modeler.Build();
codeGenerator.NormalizeClientModel(sc);
codeGenerator.Generate(sc).GetAwaiter().GetResult();
return fileSystem;
}
public AzureCSharpCodeGenerator(Settings settings) : base(settings)
{
_namer = new AzureCSharpCodeNamer(settings);
IsSingleFileGenerationSupported = true;
pageClasses = new Dictionary<KeyValuePair<string, string>, string>();
}
public void TestClientNameRubyNormalization()
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
};
var modeler = new SwaggerModeler(setting);
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel, setting);
var namer = new RubyCodeNamer();
namer.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Methods.Count);
Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].GetClientName());
Assert.Equal("version", clientModel.Methods[0].Parameters[1].GetClientName());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Properties[0].GetClientName());
Assert.Equal("_version", clientModel.Properties[1].GetClientName());
Assert.Equal("subscription", clientModel.Properties[0].Name);
Assert.Equal("_version", clientModel.Properties[1].Name);
var type = clientModel.ModelTypes.First();
Assert.Equal("error_code", type.Properties[0].Name);
Assert.Equal("error_message", type.Properties[1].Name);
Assert.Equal("parent_error", type.Properties[2].Name);
}
public void TestClientModelClientName()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Methods.Count);
Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);
Assert.Equal("subscriptionId", clientModel.Methods[0].Parameters[0].Name.FixedValue);
Assert.Equal("apiVersion", clientModel.Methods[0].Parameters[1].Name.FixedValue);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal("Subscription", clientModel.Properties[0].Name);
Assert.Equal("_version", clientModel.Properties[1].Name);
Assert.Equal("subscriptionId", clientModel.Properties[0].Name.FixedValue);
Assert.Equal("apiVersion", clientModel.Properties[1].Name.FixedValue);
Assert.Equal(1, clientModel.ModelTypes.Count);
var type = clientModel.ModelTypes.First();
Assert.Equal("ErrorCode", type.Properties[0].Name);
Assert.Equal("ErrorMessage", type.Properties[1].Name);
Assert.Equal("ParentError", type.Properties[2].Name);
Assert.Equal("code", type.Properties[0].Name.FixedValue);
Assert.Equal("message", type.Properties[1].Name.FixedValue);
Assert.Equal("parentError", type.Properties[2].Name.FixedValue);
}
}
