private static async Task GeneratePaymentSdk()
{
if (!baseUrl.EndsWith("/"))
{
baseUrl += "/";
}
var url = baseUrl + "swagger/v1/swagger.json";
var document = await SwaggerDocument.FromUrlAsync(url);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "ApiClient",
GenerateClientInterfaces = true,
OperationNameGenerator = new SingleClientFromOperationIdOperationNameGenerator(),
ExceptionClass = "ApiClientException",
InjectHttpClient = true,
CSharpGeneratorSettings =
{
Namespace = "ServerlessTemplate",
ClassStyle = NJsonSchema.CodeGeneration.CSharp.CSharpClassStyle.Poco,
ArrayType = "System.Collections.Generic.List"
},
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
var path = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..\\..\\..\\..\\Client\\ApiClient.cs"));
File.WriteAllText(path, code);
Console.WriteLine("Api client generated");
}
public static async Task Main(string[] args)
{
var document = await SwaggerDocument.FromUrlAsync("http://localhost:49530/swagger/docs/v1");
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "CarClient",
CSharpGeneratorSettings = { Namespace = "Example" }
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
var clientFilePath = Path.Combine(Assembly.GetExecutingAssembly().Location, "../../../CarClient.cs");
if (!File.Exists(clientFilePath))
{
File.Create(clientFilePath);
}
using (var tw = new StreamWriter(clientFilePath, false))
{
await tw.WriteAsync(code).ConfigureAwait(false);
}
}
public static (bool isSinlgeClient, string typeName) GenerateCSharp(SwaggerDocument document, ApiClientDefinition definition)
{
var nameGenerator = new CustomNameGenerator();
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true,
OperationNameGenerator = nameGenerator,
GenerateOptionalParameters = true,
};
settings.CSharpGeneratorSettings.ClassStyle = CSharpClassStyle.Poco;
settings.CSharpGeneratorSettings.Namespace = definition.Namespace;
settings.CSharpGeneratorSettings.ArrayType = "System.Collections.Generic.List";
settings.CSharpGeneratorSettings.PropertyNameGenerator =
new MyPropertyNameGenerator(c => ConversionUtilities.ConvertToUpperCamelCase(c, true));
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var csharp = generator.GenerateFile();
var newClient = InjectWrapperClass(csharp, Path.GetFileNameWithoutExtension(definition.CSharpClient), document, settings.OperationNameGenerator, out var isSinlgeClient, out var wrapperTypeName);
definition.IsSingleClient = isSinlgeClient;
if (definition.GenerateWrapperClass)
{
csharp = newClient;
}
File.WriteAllText(definition.CSharpClient, csharp);
return(isSinlgeClient, wrapperTypeName);
}
public DotvvmSwaggerToCSharpClientGenerator(SwaggerDocument document, SwaggerToCSharpClientGeneratorSettings settings,
SwaggerToCSharpTypeResolver resolver)
: base(document, settings, resolver)
{
this.document = document;
this.resolver = resolver;
}
private static async Task GenerateGlossarySdk()
{
if (!baseUrl.EndsWith("/"))
{
baseUrl += "/";
}
var url = baseUrl + "swagger/v1/swagger.json";
var document = await SwaggerDocument.FromUrlAsync(url);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "GlossaryClient",
GenerateClientInterfaces = true,
OperationNameGenerator = new SingleClientFromOperationIdOperationNameGenerator(),
ExceptionClass = "GlossaryClientException",
InjectHttpClient = true,
CSharpGeneratorSettings =
{
Namespace = "Glossary.Client",
ClassStyle = NJsonSchema.CodeGeneration.CSharp.CSharpClassStyle.Poco,
ArrayType = "System.Collections.Generic.List"
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
code = code.Replace("Required = Newtonsoft.Json.Required.Always", "Required = Newtonsoft.Json.Required.Default");
var path = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..\\..\\..\\..\\Client\\GlossaryClient.cs"));
File.WriteAllText(path, code);
Console.WriteLine("Glossary sdk generated");
}
public async Task GenerateAsync()
{
//var httpClient = new System.Net.Http.HttpClient();
//string content = await httpClient.GetStringAsync("https://qa.trunovate.com/entitymanager/swagger/1.1.0.0/swagger.json");
string content = File.ReadAllText(Swagger);
var dir = Path.GetFullPath(Output);
var fileSink = new FileSink(dir);
var document = await SwaggerDocument.FromJsonAsync(content);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
CSharpGeneratorSettings =
{
TemplateFactory = new SwaggerTemplateFactory(document, fileSink, Subsystem, ServiceName)
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
_ = generator.GenerateFile();
Console.WriteLine(dir);
}
private static void BuildAssemblySingleClientFromOpId(SwaggerDocument document, string location, AssemblyName name, string nameSpace, ref string typeName, ConnectionProperties props)
{
typeName = "Client";
var settings = new SwaggerToCSharpClientGeneratorSettings
{
GenerateClientClasses = true,
GenerateOptionalParameters = true,
ClassName = "{controller}Client",
OperationNameGenerator = new SingleClientFromOperationIdOperationNameGenerator(),
CSharpGeneratorSettings =
{
Namespace = nameSpace
},
};
if (props.InjectHttpClient)
{
settings.DisposeHttpClient = false;
settings.ClientBaseClass = nameSpace + ".MyClient";
settings.UseHttpClientCreationMethod = true;
settings.DisposeHttpClient = props.DisposeHttpClient;
}
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
code = AddHttpClientInjectCode(code, props, nameSpace);
CompilerResults results;
var assemblyNames = new List <string>()
{
"System.dll",
"System.Core.dll",
"System.Xml.dll",
"System.Xml.Linq.dll",
"System.Runtime.Serialization.dll",
"System.Net.Http.dll",
"LINQPad.exe",
"System.ComponentModel.DataAnnotations.dll",
};
assemblyNames.Add(Path.Combine(location, "Newtonsoft.Json.dll"));
using (var codeProvider = new CSharpCodeProvider())
{
var options = new CompilerParameters(
assemblyNames.ToArray(),
name.CodeBase,
true);
results = codeProvider.CompileAssemblyFromSource(options, code);
}
if (results.Errors.Count > 0)
{
throw new Exception
("Cannot compile typed context: " + results.Errors[0].ErrorText + " (line " + results.Errors[0].Line + ")");
}
}
/// <summary>Initializes a new instance of the <see cref="CSharpExceptionDescriptionModel" /> class.</summary>
/// <param name="type">The type.</param>
/// <param name="description">The description.</param>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="settings">The settings.</param>
public CSharpExceptionDescriptionModel(string type, string description, string controllerName, SwaggerToCSharpClientGeneratorSettings settings)
{
_type = type;
_settings = settings;
_controllerName = controllerName;
Description = !string.IsNullOrEmpty(description) ? description : "A server side error occurred.";
}
public ClientTemplateModel(string controllerName, IList <OperationModel> operations, SwaggerService service, SwaggerToCSharpClientGeneratorSettings settings)
{
_service = service;
_settings = settings;
Class = controllerName;
Operations = operations;
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToCSharpClientGenerator" /> class.</summary>
/// <param name="document">The Swagger document.</param>
/// <param name="settings">The settings.</param>
/// <param name="resolver">The resolver.</param>
/// <exception cref="ArgumentNullException"><paramref name="document" /> is <see langword="null" />.</exception>
public CSharpCodeGen(SwaggerDocument document, SwaggerToCSharpClientGeneratorSettings settings, CSharpTypeResolver resolver)
: base(document, settings, resolver)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
Document = document;
}
/// <summary>Initializes a new instance of the <see cref="ClientTemplateModel" /> class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">The class name of the controller.</param>
/// <param name="operations">The operations.</param>
/// <param name="service">The service.</param>
/// <param name="settings">The settings.</param>
public ClientTemplateModel(string controllerName, string controllerClassName, IList <OperationModel> operations, SwaggerService service, SwaggerToCSharpClientGeneratorSettings settings)
{
_service = service;
_settings = settings;
Class = controllerClassName;
ExceptionClass = _settings.ExceptionClass.Replace("{controller}", controllerName);
Operations = operations;
}
/// <summary>Initializes a new instance of the <see cref="ClientTemplateModel" /> class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">The class name of the controller.</param>
/// <param name="operations">The operations.</param>
/// <param name="document">The Swagger document.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="settings">The settings.</param>
public ClientTemplateModel(string controllerName, string controllerClassName, IList <OperationModel> operations,
SwaggerDocument document, JsonSchema4 exceptionSchema, SwaggerToCSharpClientGeneratorSettings settings)
{
_document = document;
_exceptionSchema = exceptionSchema;
_settings = settings;
Class = controllerClassName;
ExceptionClass = _settings.ExceptionClass.Replace("{controller}", controllerName);
Operations = operations;
}
/// <summary>Initializes a new instance of the <see cref="ClientTemplateModel" /> class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">The class name of the controller.</param>
/// <param name="operations">The operations.</param>
/// <param name="document">The Swagger document.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="settings">The settings.</param>
public ClientTemplateModel(string controllerName, string controllerClassName, IList<OperationModel> operations,
SwaggerDocument document, JsonSchema4 exceptionSchema, SwaggerToCSharpClientGeneratorSettings settings)
{
_document = document;
_exceptionSchema = exceptionSchema;
_settings = settings;
Class = controllerClassName;
ExceptionClass = _settings.ExceptionClass.Replace("{controller}", controllerName);
Operations = operations;
}
public string Gen(SwaggerDocument service, SwaggerToolSettings setting)
{
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
ClassName = setting.CSharpGen.ClassName,
CSharpGeneratorSettings = { Namespace = setting.CSharpGen.Namespace }
};
var generator = new SwaggerToCSharpClientGenerator(service, settings);
var code = generator.GenerateFile();
return(code);
}
public static (bool isSingleClient, string typeName) GenerateCSharp(SwaggerDocument document, ApiClientDefinition definition, bool promptOnFileOverwrite)
{
var className = Path.GetFileNameWithoutExtension(definition.CSharpClient);
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true,
OperationNameGenerator = new CustomOperationNameGenerator(),
GenerateOptionalParameters = true,
CSharpGeneratorSettings =
{
ClassStyle = CSharpClassStyle.Poco,
Namespace = definition.Namespace,
ArrayType = "System.Collections.Generic.List",
PropertyNameGenerator = new CustomPropertyNameGenerator(c => ConversionUtilities.ConvertToUpperCamelCase(c,true)),
}
};
// detect whether there will be multiple clients or just one
var clientNames = document.Operations
.Select(o => settings.OperationNameGenerator.GetClientName(document, o.Path, o.Method, o.Operation))
.Distinct()
.ToArray();
definition.IsSingleClient = clientNames.Length == 1;
if (definition.IsSingleClient)
{
// set the class name only when Swagger generates one client, otherwise all classes would have the same name
settings.ClassName = className;
}
settings.CSharpGeneratorSettings.TypeNameGenerator =
new DotvmmCSharpTypeNameGenerator(settings.CSharpGeneratorSettings, document);
settings.CSharpGeneratorSettings.TemplateFactory = new DotvvmClientTemplateFactory(settings.CodeGeneratorSettings, new[] {
typeof(CSharpGeneratorSettings).Assembly,
typeof(SwaggerToCSharpGeneratorSettings).Assembly
});
var resolver = SwaggerToCSharpTypeResolver.CreateWithDefinitions(settings.CSharpGeneratorSettings, document);
var generator = new DotvvmSwaggerToCSharpClientGenerator(document, settings, resolver);
var csharp = generator.GenerateFile();
if (definition.GenerateWrapperClass && !definition.IsSingleClient)
{
csharp = ApiClientUtils.InjectWrapperClass(csharp, className, clientNames);
}
FileSystemHelpers.WriteFile(definition.CSharpClient, csharp, promptOnFileOverwrite);
return(definition.IsSingleClient, className);
}
public async Task GenerateCSharp()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
File.WriteAllText(CSharpPath, generator.GenerateFile());
}
private static void BuildAssemblyMultiClientFromOpId(SwaggerDocument document, string location, AssemblyName name, string nameSpace, ref string typeName)
{
typeName = "Api";
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "{controller}Client",
OperationNameGenerator = new MultipleClientsFromOperationIdOperationNameGenerator(), // this is default
CSharpGeneratorSettings =
{
Namespace = nameSpace
},
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
code = code.Replace(nameSpace + "\n{", nameSpace + "\n{" + " public class " + typeName + "{ ");
code += " }";
CompilerResults results;
var assemblyNames = new List <string>()
{
"System.dll",
"System.Core.dll",
"System.Xml.dll",
"System.Runtime.Serialization.dll",
"System.Net.Http.dll",
"System.ComponentModel.DataAnnotations.dll",
};
assemblyNames.Add(Path.Combine(location, "Newtonsoft.Json.dll"));
using (var codeProvider = new CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v4.0" }
}))
{
var options = new CompilerParameters(
assemblyNames.ToArray(),
name.CodeBase,
true);
results = codeProvider.CompileAssemblyFromSource(options, code);
}
if (results.Errors.Count > 0)
{
throw new Exception
("Cannot compile typed context: " + results.Errors[0].ErrorText + " (line " + results.Errors[0].Line + ")");
}
}
public async Task GenerateCSharp()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true,
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
Context.ReturnFile(Encoding.UTF8.GetBytes(generator.GenerateFile()), "ApiClient.cs", "text/plain");
//File.WriteAllText(CSharpPath, generator.GenerateFile());
}
public async static Task <string> GenerateFromUrl(string url, string namespaceName, string className)
{
var document = await SwaggerDocument.FromUrlAsync(url);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = className,
CSharpGeneratorSettings =
{
Namespace = namespaceName
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
return(generator.GenerateFile());
}
public byte[] GetContent(string documentPath)
{
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = _className,
CSharpGeneratorSettings =
{
Namespace = _ns
}
};
var document = SwaggerDocument.FromFileAsync(documentPath).Result;
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
return(Encoding.UTF8.GetBytes(code));
}
private static string GenerateCode(SwaggerDocument document, string className)
{
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = className,
CSharpGeneratorSettings =
{
Namespace = "OpenEvents.Client"
},
GenerateExceptionClasses = false,
GenerateClientInterfaces = true
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
return(code);
}
public string GenerateCode()
{
var doc = Task.Run(async() => await GetSwaggerDocAsync()).Result;
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateClientClasses = true,
GenerateDtoTypes = true,
OperationNameGenerator = new MultipleClientsFromOperationIdOperationNameGenerator()
};
settings.CSharpGeneratorSettings.Namespace = "FSBO.WebServices.Client";
var generator = new SwaggerToCSharpClientGenerator(doc, settings);
var code = generator.GenerateFile();
return(code);
}
static void Main(string[] args)
{
// var document = SwaggerDocument.FromUrlAsync("https://api.docxmerge.com/api/swagger/v1/swagger.json").Result;
var document = SwaggerDocument.FromUrlAsync("http://localhost:5101/swagger/v1/swagger.json").Result;
var clientSettings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "DocxmergeApi",
CSharpGeneratorSettings =
{
Namespace = "Docxmerge"
}
};
var clientGenerator = new SwaggerToCSharpClientGenerator(document, clientSettings);
var code = clientGenerator.GenerateFile();
File.WriteAllText("../Docxmerge/Api.cs", code);
}
/// <summary>Initializes a new instance of the <see cref="CSharpClientTemplateModel" /> class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">The class name of the controller.</param>
/// <param name="operations">The operations.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="document">The Swagger document.</param>
/// <param name="settings">The settings.</param>
public CSharpClientTemplateModel(
string controllerName,
string controllerClassName,
IEnumerable <CSharpOperationModel> operations,
JsonSchema4 exceptionSchema,
SwaggerDocument document,
SwaggerToCSharpClientGeneratorSettings settings)
: base(controllerName, settings)
{
_document = document;
_exceptionSchema = exceptionSchema;
_settings = settings;
Class = controllerClassName;
Operations = operations;
BaseClass = _settings.ClientBaseClass?.Replace("{controller}", controllerName);
ExceptionClass = _settings.ExceptionClass.Replace("{controller}", controllerName);
}
static async Task GenerateClient()
{
var document = await SwaggerDocument.FromUrlAsync("http://localhost:58829/swagger/v1/swagger.json");
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "PokemonLookupAPIClient",
CSharpGeneratorSettings =
{
Namespace = "PokemonLookupCSharp"
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile(NSwag.CodeGeneration.ClientGeneratorOutputType.Full);
var appFolder = Path.Combine(Directory.GetParent(Environment.CurrentDirectory).Parent.Parent.Parent.FullName, "PokemonLookupCSharp");
File.WriteAllText(Path.Combine(appFolder, "Client.cs"), code);
}
private static void GenerateCode(ExchangeSettings exchangeSettings)
{
try
{
Console.WriteLine($"Generating Documentation for {exchangeSettings.ExchangeName}");
var document =
SwaggerYamlDocument.FromUrlAsync(exchangeSettings.SwaggerFileUrl).Result;
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = $"{exchangeSettings.ExchangeName}Client",
CSharpGeneratorSettings =
{
Namespace = $"CryptoSharp.Client.Exchanges.{exchangeSettings.ExchangeName}",
SchemaType = SchemaType.OpenApi3,
ClassStyle = CSharpClassStyle.Poco,
},
GenerateClientInterfaces = true,
CodeGeneratorSettings = { SchemaType = SchemaType.OpenApi3 },
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
// hack to replace double by decimal
var regex = new Regex("\\sdouble\\s", RegexOptions.Multiline);
code = regex.Replace(code, " decimal ");
if (!Directory.Exists(_generatedDirectory))
{
Directory.CreateDirectory(_generatedDirectory);
}
File.WriteAllText($"{ _generatedDirectory}/{exchangeSettings.ExchangeName}Client.cs", code);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public async Task GenerateCSharp()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true,
OperationNameGenerator = new CustomNameGenerator(),
GenerateOptionalParameters = true,
};
settings.CSharpGeneratorSettings.Namespace = Namespace;
settings.CSharpGeneratorSettings.PropertyNameGenerator = new MyPropertyNameGenerator(c => ConversionUtilities.ConvertToUpperCamelCase(c, true));
var generator = new SwaggerToCSharpClientGenerator(document, settings);
Context.ReturnFile(Encoding.UTF8.GetBytes(generator.GenerateFile()), "ApiClient.cs", "text/plain");
//File.WriteAllText(CSharpPath, generator.GenerateFile());
}
static async Task Generate()
{
var document = await SwaggerDocument.FromUrlAsync("https://goldennumber.aiedu.msra.cn/swagger/v1%20-%20English/swagger.json");
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = "GoldenNumberService",
CSharpGeneratorSettings =
{
Namespace = "GoldenNumber"
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
var code = generator.GenerateFile();
var copyright = "// Copyright (c) Microsoft. All rights reserved.\r\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\r\n\r\n";
File.WriteAllText("GoldenNumberService.cs", copyright + code.Replace("\r\n", "\n").Replace("\n", "\r\n"));
}
public static (bool isSingleClient, string typeName) GenerateCSharp(SwaggerDocument document, ApiClientDefinition definition)
{
var settings = new SwaggerToCSharpClientGeneratorSettings()
{
GenerateSyncMethods = true,
OperationNameGenerator = new CustomOperationNameGenerator(),
GenerateOptionalParameters = true,
CSharpGeneratorSettings =
{
ClassStyle = CSharpClassStyle.Poco,
Namespace = definition.Namespace,
ArrayType = "System.Collections.Generic.List",
PropertyNameGenerator = new CustomPropertyNameGenerator(c => ConversionUtilities.ConvertToUpperCamelCase(c,true)),
}
};
settings.CSharpGeneratorSettings.TypeNameGenerator =
new DotvmmCSharpTypeNameGenerator(settings.CSharpGeneratorSettings, document);
settings.CSharpGeneratorSettings.TemplateFactory = new DotvvmClientTemplateFactory(settings.CodeGeneratorSettings, new[] {
typeof(CSharpGeneratorSettings).Assembly,
typeof(SwaggerToCSharpGeneratorSettings).Assembly
});
var resolver = SwaggerToCSharpTypeResolver.CreateWithDefinitions(settings.CSharpGeneratorSettings, document);
var generator = new DotvvmSwaggerToCSharpClientGenerator(document, settings, resolver);
var csharp = generator.GenerateFile();
var newClient = ApiClientUtils.InjectWrapperClass(csharp, Path.GetFileNameWithoutExtension(definition.CSharpClient),
document, settings.OperationNameGenerator, out var isSingleClient, out var wrapperTypeName);
definition.IsSingleClient = isSingleClient;
if (definition.GenerateWrapperClass)
{
csharp = newClient;
}
File.WriteAllText(definition.CSharpClient, csharp);
return(isSingleClient, wrapperTypeName);
}
public static void Main(string[] args)
{
var document = SwaggerDocument.FromUrlAsync("http://*****:*****@"..\..\..\..\Squidex.ClientLibrary\Management\Generated.cs", code);
}
public void When_generating_CSharp_code_then_output_contains_expected_classes()
{
// Arrange
var service = CreateService();
//// Act
var settings = new SwaggerToCSharpClientGeneratorSettings {
ClassName = "MyClass"
};
settings.CSharpGeneratorSettings.Namespace = "MyNamespace";
var generator = new SwaggerToCSharpClientGenerator(service, settings);
var code = generator.GenerateFile();
// Assert
Assert.IsTrue(code.Contains("namespace MyNamespace"));
Assert.IsTrue(code.Contains("class MyClass"));
Assert.IsTrue(code.Contains("class Person"));
Assert.IsTrue(code.Contains("class Address"));
}
