// TODO: localize the diagnostic strings
// checks that all the template sources are under the template root, and they exist.
internal bool AreAllTemplatePathsValid(IRunnableProjectConfig templateConfig, RunnableProjectTemplate runnableTemplate)
{
ITemplateEngineHost host = runnableTemplate.Source.EnvironmentSettings.Host;
if (runnableTemplate.TemplateSourceRoot == null)
{
host.LogDiagnosticMessage(string.Empty, "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateRootOutsideInstallSource, runnableTemplate.Name), "Authoring");
return(false);
}
// check if any sources get out of the mount point
bool allSourcesValid = true;
foreach (FileSourceMatchInfo source in templateConfig.Sources)
{
try
{
IFile file = runnableTemplate.TemplateSourceRoot.FileInfo(source.Source);
if (file?.Exists ?? false)
{
allSourcesValid = false;
host.LogDiagnosticMessage(string.Empty, "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateNameDisplay, runnableTemplate.Name), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateSourceRoot, runnableTemplate.TemplateSourceRoot.FullPath), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_SourceMustBeDirectory, source.Source), "Authoring");
}
else
{
IDirectory sourceRoot = runnableTemplate.TemplateSourceRoot.DirectoryInfo(source.Source);
if (!(sourceRoot?.Exists ?? false))
{
// non-existant directory
allSourcesValid = false;
host.LogDiagnosticMessage(string.Empty, "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateNameDisplay, runnableTemplate.Name), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateSourceRoot, runnableTemplate.TemplateSourceRoot.FullPath), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_SourceDoesNotExist, source.Source), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_SourceIsOutsideInstallSource, sourceRoot.FullPath), "Authoring");
}
}
}
catch
{ // outside the mount point root
// TODO: after the null ref exception in DirectoryInfo is fixed, change how this check works.
allSourcesValid = false;
host.LogDiagnosticMessage(string.Empty, "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateNameDisplay, runnableTemplate.Name), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateSourceRoot, runnableTemplate.TemplateSourceRoot.FullPath), "Authoring");
host.LogDiagnosticMessage(string.Format(LocalizableStrings.Authoring_TemplateRootOutsideInstallSource, source.Source), "Authoring");
}
}
return(allSourcesValid);
}
public static async Task <int> Instantiate(ITemplateEngineHost host, string templateName, string name, string fallbackName, bool createDir, string aliasName, IReadOnlyDictionary <string, string> inputParameters, bool skipUpdateCheck)
{
ITemplateInfo templateInfo;
using (Timing.Over("Get single"))
{
if (!TryGetTemplate(templateName, out templateInfo))
{
return(-1);
}
}
ITemplate template = SettingsLoader.LoadTemplate(templateInfo);
if (!skipUpdateCheck)
{
host.LogMessage("Checking for updates...");
//UpdateCheck(); // this'll need params
}
string realName = name ?? template.DefaultName ?? fallbackName;
IParameterSet templateParams = SetupDefaultParamValuesFromTemplateAndHost(host, template, realName);
if (aliasName != null)
{
//TODO: Add parameters to aliases (from _parameters_ collection)
AliasRegistry.SetTemplateAlias(aliasName, template);
host.LogMessage("Alias created.");
return(0);
}
ResolveUserParameters(template, templateParams, inputParameters);
bool missingParams = CheckForMissingRequiredParameters(host, templateParams);
if (missingParams)
{
return(missingParams ? -1 : 0);
}
try
{
Stopwatch sw = Stopwatch.StartNew();
// todo: pass an implementation of ITemplateEngineHost
IComponentManager componentManager = Settings.SettingsLoader.Components;
await template.Generator.Create(host, template, templateParams, componentManager);
sw.Stop();
host.OnTimingCompleted("Content generation time", sw.Elapsed);
}
finally
{
}
return(0);
}
public static int Run(string commandName, ITemplateEngineHost host, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, string[] args)
{
ExtendedCommandParser app = new ExtendedCommandParser()
{
Name = $"dotnet {commandName}",
FullName = LocalizableStrings.CommandDescription
};
SetupInternalCommands(app);
CommandArgument templateName = app.Argument("template", LocalizableStrings.TemplateArgumentHelp);
New3Command instance = new New3Command(commandName, host, onFirstRun, app, templateName);
app.OnExecute(instance.ExecuteAsync);
int result;
try
{
using (Timing.Over("Execute"))
{
result = app.Execute(args);
}
}
catch (Exception ex)
{
AggregateException ax = ex as AggregateException;
while (ax != null && ax.InnerExceptions.Count == 1)
{
ex = ax.InnerException;
ax = ex as AggregateException;
}
Reporter.Error.WriteLine(ex.Message.Bold().Red());
while (ex.InnerException != null)
{
ex = ex.InnerException;
ax = ex as AggregateException;
while (ax != null && ax.InnerExceptions.Count == 1)
{
ex = ax.InnerException;
ax = ex as AggregateException;
}
Reporter.Error.WriteLine(ex.Message.Bold().Red());
}
Reporter.Error.WriteLine(ex.StackTrace.Bold().Red());
result = 1;
}
return(result);
}
public void List_CannotParseMultipleArgs(string command)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
Assert.NotEmpty(parseResult.Errors);
Assert.Equal("Unrecognized command or argument 'cr2'.", parseResult.Errors.First().Message);
}
public void Install_GetSuggestionsAfterOptionWithoutArg()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new install --nuget-source ");
var result = parseResult.GetCompletions().ToArray();
Assert.Empty(result);
}
public void Update_Error_WhenArguments(string commandName)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($"new {commandName} source");
Assert.True(parseResult.Errors.Any());
Assert.Contains(parseResult.Errors, error => error.Message.Contains("Unrecognized command or argument 'source'"));
}
private static void FirstRun(ITemplateEngineHost host, IInstaller installer)
{
var templatesDir = Path.Combine(Paths.Global.BaseDir, "Templates");
if (templatesDir.Exists())
{
var layoutIncludedPackages = host.FileSystem.EnumerateFiles(templatesDir, "*.nupkg", SearchOption.TopDirectoryOnly);
installer.InstallPackages(layoutIncludedPackages);
}
}
public void Update_Legacy_CanParseInteractiveOption(string testCase)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(testCase);
UpdateCommandArgs args = new UpdateCommandArgs((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
Assert.True(args.Interactive);
}
public void Search_Legacy_CannotParseArgsAtBothLevels()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new smth --search smth-else");
Assert.NotEmpty(parseResult.Errors);
Assert.Equal("Unrecognized command or argument(s): 'smth'.", parseResult.Errors.First().Message);
}
public void Search_CannotParseOptionsAtNewLevel(string command, string expectedFilter)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
Assert.NotEmpty(parseResult.Errors);
Assert.Equal($"Unrecognized command or argument(s): '{expectedFilter}','filter-value'.", parseResult.Errors.First().Message);
}
public void Search_CannotParseUnknownColumns(string command)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
Assert.NotEmpty(parseResult.Errors);
Assert.Contains("Argument 'c1' not recognized. Must be one of:", parseResult.Errors.First().Message);
}
public Task Search_GetAllSuggestions()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new search ");
var result = parseResult.GetCompletions().ToArray();
return(Verifier.Verify(result, _verifySettings.Settings));
}
public void CanShowUsage_ForMultipleShortNames()
{
ITemplateEngineHost host = TestHost.GetVirtualHost();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
StringWriter sw = new StringWriter();
HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw);
InstantiateCommand.ShowUsage(myCommand, new[] { "short-name1", "short-name2" }, helpContext);
Assert.Equal($"Usage:{Environment.NewLine} new short-name1 [options] [template options]{Environment.NewLine} new short-name2 [options] [template options]{Environment.NewLine}{Environment.NewLine}", sw.ToString());
}
public void Instantiate_CanParseTemplateWithOptions()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new console --framework net5.0");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
Assert.Equal("console", args.ShortName);
Assert.Contains("--framework", args.RemainingArguments);
Assert.Contains("net5.0", args.RemainingArguments);
}
public bool TryGetTemplateFromConfigInfo(IFileSystemInfo templateFileConfig, out ITemplate template, IFileSystemInfo localeFileConfig = null, IFile hostTemplateConfigFile = null, string baselineName = null)
{
IFile templateFile = templateFileConfig as IFile;
if (templateFile == null)
{
template = null;
return(false);
}
IFile localeFile = localeFileConfig as IFile;
try
{
JObject baseSrcObject = ReadJObjectFromIFile(templateFile);
JObject srcObject = MergeAdditionalConfiguration(baseSrcObject, templateFileConfig);
JObject localeSourceObject = null;
if (localeFile != null)
{
localeSourceObject = ReadJObjectFromIFile(localeFile);
}
ISimpleConfigModifiers configModifiers = new SimpleConfigModifiers()
{
BaselineName = baselineName
};
SimpleConfigModel templateModel = SimpleConfigModel.FromJObject(templateFile.MountPoint.EnvironmentSettings, srcObject, configModifiers, localeSourceObject);
if (!CheckGeneratorVersionRequiredByTemplate(templateModel.GeneratorVersions))
{ // template isn't compatible with this generator version
template = null;
return(false);
}
RunnableProjectTemplate runnableProjectTemplate = new RunnableProjectTemplate(srcObject, this, templateFile, templateModel, null, hostTemplateConfigFile);
if (!AreAllTemplatePathsValid(templateModel, runnableProjectTemplate))
{
template = null;
return(false);
}
template = runnableProjectTemplate;
return(true);
}
catch (Exception ex)
{
ITemplateEngineHost host = templateFileConfig.MountPoint.EnvironmentSettings.Host;
host.LogMessage($"Error reading template from file: {templateFile.FullPath} | Error = {ex.Message}");
}
template = null;
return(false);
}
#pragma warning restore xUnit1004 // Test methods should not be skipped
public void Install_GetSuggestionsAfterInteractive()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new install --interactive ");
var result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
Assert.Equal(2, result.Length);
Assert.Contains("--nuget-source", result);
}
public void Uninstall_NoArguments(string commandName)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($"new {commandName}");
UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.Empty(parseResult.Errors);
Assert.Empty(args.TemplatePackages);
}
public void Update_CanParseAddSourceOption_MultipleEntries(string testCase)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(testCase);
UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult);
Assert.Equal(2, args.AdditionalSources?.Count);
Assert.Contains("my-custom-source1", args.AdditionalSources);
Assert.Contains("my-custom-source2", args.AdditionalSources);
}
public void Search_CanParseColumnsAll(string command)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
Assert.True(args.DisplayAllColumns);
}
public void Instantiate_CanSuggestTemplate_StartsWith()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new co");
var suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
Assert.Single(suggestions);
Assert.Equal("console", suggestions.Single());
}
public void NupkgReinstallDoesntRemoveTemplates()
{
const string nupkgToInstallName = "TestNupkgInstallTemplate.0.0.1.nupkg";
const string checkTemplateName = "nupkginstall"; // this is the short name of the template in the nupkg that gets installed.
ITemplateEngineHost host = CreateHostWithVirtualizedHive(HostIdentifier, HostVersion);
Assert.NotNull(host);
ITelemetryLogger telemetryLogger = new TelemetryLogger(null, false);
int initializeResult = New3Command.Run(CommandName, host, telemetryLogger, null, new string[] { });
Assert.Equal(0, initializeResult);
string codebase = typeof(NupkgInstallTests).GetTypeInfo().Assembly.CodeBase;
Uri cb = new Uri(codebase);
string asmPath = cb.LocalPath;
string dir = Path.GetDirectoryName(asmPath);
string pathToInstall = Path.Combine(dir, "TemplateInstallTests", "TestTemplates", nupkgToInstallName);
Assert.True(File.Exists(pathToInstall), $"directory didnt exist: {pathToInstall}");
string[] installArgs = new[]
{
"--install",
pathToInstall
};
// install the test pack
int firstInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs);
Assert.Equal(0, firstInstallResult);
EngineEnvironmentSettings environemnt = new EngineEnvironmentSettings(host, x => new SettingsLoader(x));
SettingsLoader settingsLoader = (SettingsLoader)environemnt.SettingsLoader;
IHostSpecificDataLoader hostDataLoader = new MockHostSpecificDataLoader();
// check that the template was installed from the first install.
IReadOnlyCollection <ITemplateMatchInfo> allTemplates = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader);
Assert.Contains(checkTemplateName, allTemplates.Select(t => t.Info.ShortName));
// install the same test pack again
int secondInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs);
Assert.Equal(0, secondInstallResult);
settingsLoader.Reload();
// check that the template is still installed after the second install.
IReadOnlyCollection <ITemplateMatchInfo> allTemplatesAfterSecondInstall = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader);
Assert.Contains(checkTemplateName, allTemplatesAfterSecondInstall.Select(t => t.Info.ShortName));
}
public void Install_Legacy_CanParseMultipleArgs(string testCase)
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(testCase);
InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.Equal(2, args.TemplatePackages.Count);
Assert.Contains("source1", args.TemplatePackages);
Assert.Contains("source2", args.TemplatePackages);
}
public void Install_Legacy_Error_NoArguments()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($"new --install --interactive");
Assert.True(parseResult.Errors.Any());
Assert.Contains(parseResult.Errors, error => error.Message.Contains("Required argument missing"));
Assert.Throws <ArgumentException>(() => new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult));
}
private static int Main(string[] args)
{
VerificationLookup["dir_exists"] = CheckDirectoryExists;
VerificationLookup["file_exists"] = CheckFileExists;
VerificationLookup["dir_does_not_exist"] = CheckDirectoryDoesNotExist;
VerificationLookup["file_does_not_exist"] = CheckFileDoesNotExist;
VerificationLookup["file_contains"] = CheckFileContains;
VerificationLookup["file_does_not_contain"] = CheckFileDoesNotContain;
int batteryCount = int.Parse(args[0], CultureInfo.InvariantCulture);
string outputPath = args[batteryCount + 1];
List <string> passThroughArgs = new List <string>();
passThroughArgs.AddRange(args.Skip(2 + batteryCount));
passThroughArgs.Add("--debug:ephemeral-hive");
ITemplateEngineHost host = CreateHost();
host.VirtualizeDirectory(outputPath);
var command = NewCommandFactory.Create(CommandName, _ => host, _ => new TelemetryLogger(null), new NewCommandCallbacks());
int result = ParserFactory.CreateParser(command).Parse(passThroughArgs.ToArray()).Invoke();
bool verificationsPassed = false;
for (int i = 0; i < batteryCount; ++i)
{
string verificationsFile = args[i + 1];
string verificationsFileContents = File.ReadAllText(verificationsFile);
JArray verifications = JArray.Parse(verificationsFileContents);
try
{
verificationsPassed = RunVerifications(verifications, host.FileSystem, outputPath);
}
catch (Exception ex)
{
verificationsPassed = false;
Console.Error.WriteLine(ex.ToString());
}
}
Console.Error.WriteLine(" ");
Console.Error.WriteLine("Output Files:");
foreach (string fileName in host.FileSystem.EnumerateFiles(outputPath, "*", SearchOption.AllDirectories))
{
Console.Error.WriteLine(fileName.Substring(outputPath.Length));
}
return(result != 0 ? result : batteryCount == 0 ? 0 : verificationsPassed ? 0 : 1);
}
private static string GetDefaultHostSettingsDir(ITemplateEngineHost host, string?userDir = null, string?globalDir = null)
{
if (string.IsNullOrWhiteSpace(host.HostIdentifier))
{
throw new ArgumentException($"{nameof(host.HostIdentifier)} of {nameof(host)} cannot be null or whitespace.", nameof(host));
}
if (string.IsNullOrWhiteSpace(userDir) && string.IsNullOrWhiteSpace(globalDir))
{
throw new ArgumentException($"both {nameof(userDir)} and {nameof(globalDir)} cannot be null or whitespace.", nameof(userDir));
}
return(Path.Combine(globalDir ?? GetDefaultGlobalSettingsDir(userDir !), host.HostIdentifier));
}
public async Task TestGetTemplateResolutionResult_ConstraintsMismatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", identity: "Console.App.T1")
.WithConstraints(new TemplateConstraintInfo("test", "no")));
templatesToSearch.Add(
new MockTemplateInfo("console2", identity: "Console.App.T2")
.WithConstraints(new TemplateConstraintInfo("test", "bad-param")));
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: new[] { (typeof(ITemplateConstraintFactory), (IIdentifiedComponent) new TestConstraintFactory("test")) });
public void Instantiate_CanSuggestTemplateOption_StartsWith()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse("new console --framework net7.0 --l");
var suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
Assert.Equal(2, suggestions.Length);
Assert.Contains("--langVersion", suggestions);
Assert.Contains("--language", suggestions);
}
static int Main(string[] args)
{
VerificationLookup["dir_exists"] = CheckDirectoryExists;
VerificationLookup["file_exists"] = CheckFileExists;
VerificationLookup["dir_does_not_exist"] = CheckDirectoryDoesNotExist;
VerificationLookup["file_does_not_exist"] = CheckFileDoesNotExist;
VerificationLookup["file_contains"] = CheckFileContains;
VerificationLookup["file_does_not_contain"] = CheckFileDoesNotContain;
string[] passthroughArgs = new string[args.Length - 2];
for (int i = 0; i < passthroughArgs.Length; ++i)
{
passthroughArgs[i] = args[i + 2];
}
string verificationsFile = args[0];
string outputPath = args[1];
string verificationsFileContents = File.ReadAllText(verificationsFile);
JArray verifications = JArray.Parse(verificationsFileContents);
ITemplateEngineHost host = CreateHost();
string profileDir = Environment.ExpandEnvironmentVariables("%USERPROFILE%");
if (string.IsNullOrWhiteSpace(profileDir))
{
profileDir = Environment.ExpandEnvironmentVariables("$HOME");
}
if (string.IsNullOrWhiteSpace(profileDir))
{
Console.Error.WriteLine("Could not determine home directory");
return(0);
}
host.VirtualizeDirectory(Path.Combine(profileDir, ".templateengine"));
host.VirtualizeDirectory(outputPath);
int result = New3Command.Run(CommandName, host, FirstRun, passthroughArgs);
bool verificationsPassed = false;
try
{
verificationsPassed = RunVerifications(verifications, host.FileSystem, outputPath);
}
catch (Exception ex)
{
verificationsPassed = false;
Console.Error.WriteLine(ex.ToString());
}
return(result != 0 ? result : verificationsPassed ? 0 : 1);
}
public void CommandExampleShowsOptionalArgWhenOptionsAreGiven()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
Command rootCommand = new Command("dotnet")
{
myCommand
};
var parseResult = rootCommand.Parse("dotnet new search template");
Assert.Equal("dotnet new search [<template-name>] --author Microsoft", Example.For <NewCommand>(parseResult).WithSubcommand <SearchCommand>().WithArgument(SearchCommand.NameArgument).WithOption(SharedOptionsFactory.CreateAuthorOption(), "Microsoft"));
}
public void CommandExampleCanShowParentCommandsBeyondNew()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
Command rootCommand = new Command("dotnet")
{
myCommand
};
var parseResult = rootCommand.Parse("dotnet new update");
Assert.Equal("dotnet new update", Example.For <NewCommand>(parseResult).WithSubcommand <UpdateCommand>());
}
