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; }