private TemplateInfo FindTemplateByShortName(string shortName, DotnetTemplateVersion version, IEngineEnvironmentSettings envSettings)
{
var loader = (InitializrSettingsLoader)envSettings.SettingsLoader;
var versionString = version == DotnetTemplateVersion.V2 ? "2.0" : "3.0";
return(loader.UserTemplateCache
.TemplateInfo
.FirstOrDefault(ti => ti.ShortNameList.Contains(shortName) && ti.Identity.EndsWith(versionString)));
}
public List <ProjectDependency> GetDependencies(string shortName, DotnetTemplateVersion dotnetTemplateVersion = DotnetTemplateVersion.V2)
{
var list = GetAllTemplates();
shortName = string.IsNullOrEmpty(shortName) ? DEFAULT_TEMPLATE : shortName;
var versionString = dotnetTemplateVersion == DotnetTemplateVersion.V2 ? "2.0" : "3.0";
var selectedTemplate = list.FirstOrDefault(x => x.ShortName == shortName && x.Identity.EndsWith(versionString));
if (selectedTemplate == null)
{
throw new InvalidDataException($"Could not find template with ShortName: {shortName ?? DEFAULT_TEMPLATE} ");
}
return(selectedTemplate.Parameters
.Where(p => p.Documentation != null && p.Documentation.ToLower().StartsWith("steeltoe:"))
.Select(p => new ProjectDependency
{
Name = GetFriendlyName(p.Name),
ShortName = p.Name,
Description = p.Documentation,
}).ToList());
}
public List <ProjectDependency> GetDependencies(string shortName, DotnetTemplateVersion version)
{
shortName = string.IsNullOrEmpty(shortName) ? DefaultTemplateName : shortName;
var list = GetAvailableTemplates();
var selectedTemplate = list.FirstOrDefault(x => x.ShortName == shortName);
if (selectedTemplate == null)
{
throw new InvalidDataException($"Could not find template with name {shortName} ");
}
// var templatePath = _templatePath + Path.DirectorySeparatorChar + selectedTemplate.Name;
var config = _mustacheConfig.GetSchema(new TemplateKey(selectedTemplate.Name, version));
return(config.Params
.Where(p => p.Description.ToLower().Contains("steeltoe"))
.Select(p => new ProjectDependency
{
Name = p.FriendlyName ?? GetFriendlyName(p.Name),
ShortName = p.Name,
Description = p.Description,
}).ToList());
}
public async Task CreateTemplate_actuators(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Actuators",
ProjectName = "testProject",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.Management.Hypermedia;", startUpContents);
Assert.Contains("using Steeltoe.Management.Endpoint;", startUpContents);
Assert.Contains("using Steeltoe.Management.CloudFoundry;", startUpContents);
Assert.Contains("services.AddCloudFoundryActuators(Configuration);", startUpContents);
}
public async Task CreateTemplate_targetVersion21(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
if (version == DotnetTemplateVersion.V3)
{
return;
}
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Actuators,SQLServer",
TemplateShortName = templateName,
ProjectName = "Foo.Bar",
TargetFrameworkVersion = "netcoreapp2.1",
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("services.AddMvc();", startUpContents);
string projectFile = files.Find(x => x.Key == "Foo.Bar.csproj").Value;
Assert.Contains("<TargetFramework>netcoreapp2.1</TargetFramework>", projectFile);
}
public async Task CreateTemplate_actuators_24(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Actuators",
SteeltoeVersion = "2.4.3",
TemplateShortName = templateName,
TemplateVersion = version,
});
var startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("services.AddCloudFoundryActuators(Configuration);", startUpContents);
}
public async Task CreateTemplate_actuators_cloudFoundry(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
Assert.NotNull(templateService);
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "CloudFoundry",
TemplateShortName = templateName,
TemplateVersion = version,
});
string programFileContents = files.Find(x => x.Key == "Program.cs").Value;
Assert.Contains("using Steeltoe.Extensions.Configuration;", programFileContents);
Assert.Contains("using Steeltoe.Extensions.Configuration.CloudFoundry;", programFileContents);
Assert.Contains(".UseCloudFoundryHosting(", programFileContents);
Assert.Contains(".AddCloudFoundry", programFileContents);
}
public async Task CreateTemplate_SqlServer(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var steeltoeVersion = "2.4.3";
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "SQLServer",
ProjectName = "testProject",
TemplateShortName = templateName,
SteeltoeVersion = steeltoeVersion,
TemplateVersion = version,
});
var fileContents = files.Find(x => x.Key == "testProject.csproj").Value;
var aspnetCoreVersion = version == DotnetTemplateVersion.V3 ? "3.1.0" : "2.1.1";
Assert.Contains($@"<PackageReference Include=""Microsoft.EntityFrameworkCore.SqlServer"" Version=""{aspnetCoreVersion}"" />", fileContents);
var startup = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains(@"using Steeltoe.CloudFoundry.Connector.SqlServer;", startup);
Assert.Contains(@"services.AddSqlServerConnection(Configuration);", startup);
if (!templateName.Contains("React"))
{ // TODO: Add demo for react app
var valuesController = files.Find(x => x.Key.EndsWith("ValuesController.cs")).Value;
Assert.Contains(@" public ValuesController([FromServices] SqlConnection dbConnection)", valuesController);
}
}
public async Task CreateTemplate_MongoDB(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "MongoDB",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.MongoDb;", startUpContents);
Assert.Contains("services.AddMongoClient(Configuration);", startUpContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using MongoDB.Driver;", valuesController);
Assert.Contains("using System.Data", valuesController);
Assert.Contains(@"public ValuesController(IMongoClient mongoClient, MongoUrl mongoUrl)", valuesController);
Assert.Contains(@"_mongoClient.ListDatabaseNames().ToList();", valuesController);
}
public async Task CreateTemplate_actuators_circuitbreakers(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Actuators,CircuitBreaker",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("services.AddCloudFoundryActuators(Configuration);", startUpContents);
Assert.Contains("using Steeltoe.CircuitBreaker.Hystrix;", startUpContents);
Assert.Contains(files, file => file.Key.EndsWith("MyCircuitBreakerCommand.cs"));
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains(@"MyCircuitBreakerCommand cb = new MyCircuitBreakerCommand(""ThisIsMyBreaker"");", valuesController);
string appSettings = files.Find(x => x.Key == "appsettings.json").Value;
Assert.DoesNotContain("#if", appSettings);
}
public async Task CreateTemplate_discovery(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Discovery",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.Discovery.Client;", startUpContents);
Assert.Contains("services.AddDiscoveryClient(Configuration);", startUpContents);
Assert.Contains("app.UseDiscoveryClient();", startUpContents);
}
public async Task CreateTemplate_Mustache_WebApi_V2_All_Test(ITemplateService templateService, string templateName, DotnetTemplateVersion version, string depString)
{
_testOutputHelper.WriteLine(depString);
await CreateTemplate_Test(templateService, templateName, version, depString);
}
public static IEnumerable <object[]> GetAllCombinations(Type templateServiceType, string templateName, DotnetTemplateVersion version, int take)
{
ITemplateService templateService;
if (templateServiceType == typeof(MustacheTemplateService))
{
templateService = new MustacheTemplateService(
TestHelper.GetConfiguration(),
new LoggerFactory().CreateLogger <MustacheTemplateService>());
}
else
{
templateService = new DotnetTemplateService(
TestHelper.GetConfiguration(),
new MemoryCache(new MemoryCacheOptions()),
new LoggerFactory().CreateLogger <DotnetTemplateService>());
}
var dependencies = templateService.GetDependencies(templateName, version);
return(from deps in GetCombinations(dependencies.Select(d => d.ShortName), take)
select new object[] { templateService, templateName, version, string.Join(",", deps) });
}
private async Task CreateTemplate_Test(ITemplateService templateService, string templateName, DotnetTemplateVersion version, string depString)
{
_testOutputHelper.WriteLine($"testing dep: --" + depString);
var archive = await templateService.GenerateProjectArchiveAsync(new GeneratorModel()
{
Dependencies = depString,
TemplateShortName = templateName,
ProjectName = "Foo.Bar",
TemplateVersion = version,
});
var zip = new ZipArchive(new MemoryStream(archive));
var dirName = Path.GetTempPath() + Path.DirectorySeparatorChar + Guid.NewGuid();
zip.ExtractToDirectory(dirName);
var startInfo = new ProcessStartInfo();
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.FileName = "dotnet";
startInfo.Arguments = "build";
startInfo.WorkingDirectory = dirName;
var process = Process.Start(startInfo);
await process.WaitForExitAsync();
var output = process.StandardOutput.ReadToEnd();
Assert.True(
output.Contains("Build succeeded."),
$"Error compiling {depString}. \n {output}");
}
public async Task CreateTemplate_RabbitMQ(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "RabbitMQ",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.RabbitMQ;", startUpContents);
Assert.Contains("services.AddRabbitMQConnection(Configuration);", startUpContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains(
@"using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;
using System.Threading;", valuesController);
Assert.Contains(@"public ValuesController(ILogger<ValuesController> logger, [FromServices] ConnectionFactory factory)", valuesController);
Assert.Contains(
@"channel.BasicPublish(exchange: """",
routingKey: queueName,
basicProperties: null,
body: body);", valuesController);
}
public async Task CreateTemplate_MySql(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "MySql",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.MySql;", startUpContents);
Assert.Contains(".AddMySqlConnection(", startUpContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using MySql.Data.MySqlClient;", valuesController);
Assert.Contains("using System.Data", valuesController);
Assert.Contains(
@"private readonly MySqlConnection _dbConnection;
public ValuesController([FromServices] MySqlConnection dbConnection)
{
_dbConnection = dbConnection;
}", valuesController);
Assert.Contains(@"DataTable dt = _dbConnection.GetSchema(""Tables"");", valuesController);
}
public async Task CreateTemplate_Redis(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Redis",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.Redis", startUpContents);
Assert.Contains("services.AddDistributedRedisCache(Configuration);", startUpContents);
Assert.Contains("// services.AddRedisConnectionMultiplexer(Configuration);", startUpContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using Microsoft.Extensions.Caching.Distributed;", valuesController);
Assert.Contains(@" public ValuesController(IDistributedCache cache)", valuesController);
Assert.Contains(@"await _cache.SetStringAsync(""MyValue1"", ""123"");", valuesController);
}
public async Task CreateTemplate_MySql_EFCore(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "MySqlEFCore",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.MySql;", startUpContents);
Assert.Contains("using Steeltoe.CloudFoundry.Connector.MySql.EFCore;", startUpContents);
}
public async Task CreateTemplate_OauthConnector(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "OAuthConnector",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.OAuth;", startUpContents);
Assert.Contains("services.AddOAuthServiceOptions(Configuration);", startUpContents);
}
public async Task CreateTemplate_postgresql(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "Postgres",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.PostgreSql;", startUpContents);
Assert.Contains("services.AddPostgresConnection(Configuration);", startUpContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using Npgsql;", valuesController);
Assert.Contains("using System.Data", valuesController);
Assert.Contains(@"public ValuesController([FromServices] NpgsqlConnection dbConnection)", valuesController);
Assert.Contains(@"DataTable dt = _dbConnection.GetSchema(""Databases"");", valuesController);
}
public async Task CreateTemplate_DynamicLogger(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "DynamicLogger",
ProjectName = "testProject",
TemplateShortName = templateName,
TemplateVersion = version,
});
string fileContents = files.Find(x => x.Key == "testProject.csproj").Value;
Assert.Contains(@"<PackageReference Include=""Steeltoe.Extensions.Logging.DynamicLogger"" Version=", fileContents);
string programFileContents = files.Find(x => x.Key == "Program.cs").Value;
Assert.Contains(@"using Steeltoe.Extensions.Logging;", programFileContents);
Assert.Contains(@"loggingBuilder.AddConfiguration(hostingContext.Configuration.GetSection(""Logging""));", programFileContents);
Assert.Contains(@"loggingBuilder.AddDynamicConsole();", programFileContents);
}
public async Task CreateTemplate_Randomvalue(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var configuration = TestHelper.GetConfiguration();
var logger = new LoggerFactory().CreateLogger <MustacheTemplateService>();
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "RandomValueConfig",
TemplateShortName = templateName,
TemplateVersion = version,
});
Assert.Contains(files, file => file.Key.EndsWith("ValuesController.cs"));
string programContents = files.Find(x => x.Key == "Program.cs").Value;
Assert.Contains("using Steeltoe.Extensions.Configuration.RandomValue;", programContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using Microsoft.Extensions.Configuration;", valuesController);
Assert.Contains(@"public ValuesController(IConfiguration config)", valuesController);
Assert.Contains(@"_config[""random:int""];", valuesController);
}
public void GetDependencies(ITemplateService templateService, string templateName, DotnetTemplateVersion dotnetTemplateVersion)
{
var deps = templateService.GetDependencies(templateName, dotnetTemplateVersion);
Assert.NotNull(deps);
Assert.NotEmpty(deps);
Assert.Contains(deps, x => x.Name == "OAuthConnector");
}
public async Task CreateTemplate_Cloudfoundry(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var configuration = TestHelper.GetConfiguration();
var logger = new LoggerFactory().CreateLogger <MustacheTemplateService>();
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "CloudFoundry",
TemplateShortName = templateName,
TemplateVersion = version,
});
string programContents = files.Find(x => x.Key == "Program.cs").Value;
Assert.Contains(".UseCloudFoundryHosting()", programContents);
Assert.Contains(".AddCloudFoundry()", programContents);
string valuesController = files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using Steeltoe.Extensions.Configuration.CloudFoundry;", valuesController);
Assert.Contains("using Microsoft.Extensions.Options;", valuesController);
Assert.Contains(@"public ValuesController(ILogger<ValuesController> logger, IOptions<CloudFoundryApplicationOptions> appOptions, IOptions<CloudFoundryServicesOptions> serviceOptions)", valuesController);
}
public async Task CreateTemplate_empty(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
Assert.NotNull(templateService);
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
TemplateShortName = templateName,
ProjectName = "Foo.Bar",
TemplateVersion = version,
});
var startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.DoesNotContain(files, file => file.Key.StartsWith("Models"));
Assert.DoesNotContain(files, file => file.Key.EndsWith("MyCircuitBreakerCommand.cs"));
Assert.DoesNotContain("AddCloudFoundryActuators", startUpContents);
var projectFile = files.Find(x => x.Key == "Foo.Bar.csproj").Value;
var targetFramework = version == DotnetTemplateVersion.V3 ? "netcoreapp3.1" : "netcoreapp2.1";
Assert.Contains($"<TargetFramework>{targetFramework}</TargetFramework>", projectFile);
}
public async Task CreateTemplate_Placeholderconfig(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var configuration = TestHelper.GetConfiguration();
var logger = new LoggerFactory().CreateLogger <MustacheTemplateService>();
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "PlaceholderConfig",
TemplateShortName = templateName,
TemplateVersion = version,
});
Assert.DoesNotContain(files, file => file.Key.EndsWith("SampleData.cs"));
Assert.Contains(files, file => file.Key.EndsWith("ValuesController.cs"));
string programContents = files.Find(x => x.Key == "Program.cs").Value;
Assert.Contains("using Steeltoe.Extensions.Configuration.PlaceholderCore;", programContents);
string valuesController =
files.Find(x => x.Key == $"Controllers{Path.DirectorySeparatorChar}ValuesController.cs").Value;
Assert.Contains("using Microsoft.Extensions.Configuration;", valuesController);
Assert.Contains(@"public ValuesController(IConfiguration config)", valuesController);
Assert.Contains(@"_config[""ResolvedPlaceholderFromEnvVariables""];", valuesController);
string appSettings = files.Find(x => x.Key == $"appsettings.json").Value;
Assert.Contains("\"ResolvedPlaceholderFromEnvVariables\": \"${PATH?NotFound}\"", appSettings);
}
public void GetDependencies_WithFriendlyNames(ITemplateService templateService, string templateName, DotnetTemplateVersion dotnetTemplateVersion)
{
var deps = templateService.GetDependencies(templateName, dotnetTemplateVersion);
Assert.NotNull(deps);
Assert.NotEmpty(deps);
Assert.Contains(deps, x => x.Name == "Cloud Foundry");
}
public async Task CreateTemplate_postgresEFCore(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
Dependencies = "PostgresEFCore",
TemplateShortName = templateName,
TemplateVersion = version,
});
string startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.Contains("using Steeltoe.CloudFoundry.Connector.PostgreSql.EFCore;", startUpContents);
Assert.Contains("services.AddDbContext<MyDbContext>(options => options.UseNpgsql(Configuration));", startUpContents);
}
public async Task CreateTemplate_react(ITemplateService templateService, string templateName, DotnetTemplateVersion version)
{
var files = await templateService.GenerateProjectFiles(new GeneratorModel()
{
ProjectName = "testProject",
TemplateShortName = templateName,
TemplateVersion = version,
});
var startUpContents = files.Find(x => x.Key == "Startup.cs").Value;
Assert.NotEmpty(startUpContents);
}
public TemplateKey(string name, DotnetTemplateVersion version)
{
Name = name;
Version = version;
}
