public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams()
{
var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group", precedence: 0)
.WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val-not-shown", defaultIfNoOptionValue: "def-val-not-shown")
.WithParameter("bool", paramType: "boolean", description: "my bool", defaultValue: "false", defaultIfNoOptionValue: "false");
var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group", precedence: 2)
.WithChoiceParameter("choice", new[] { "val1", "val3" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg")
.WithParameter("int", paramType: "integer", description: "my int", defaultValue: "0", defaultIfNoOptionValue: "10");
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
TemplateCommand templateCommand1 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
TemplateCommand templateCommand2 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]);
StringWriter sw = new StringWriter();
HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw);
InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand2, templateCommand1 }, helpContext);
return(Verifier.Verify(sw.ToString(), _verifySettings.Settings));
}
public void UniqueStartsWithValueResolvesCanonicalValueTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, string>()
{
{ "foo", "Foo value" },
{ "bar", "Bar value" }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "f");
Assert.Equal("foo", canonical);
}
private static IReadOnlyDictionary <string, IReadOnlyList <(ITemplatePackageInfo PackageInfo, IReadOnlyList <ITemplateInfo> MatchedTemplates)> > GetMockNameSearchResults()
{
Dictionary <string, IReadOnlyList <(ITemplatePackageInfo, IReadOnlyList <ITemplateInfo>)> > dataForSources = new();
ITemplateInfo sourceOneTemplateOne = new MockTemplateInfo("foo1", name: "MockFooTemplateOne", identity: "Mock.Foo.1").WithDescription("Mock Foo template one");
ITemplateInfo sourceOneTemplateTwo = new MockTemplateInfo("foo2", name: "MockFooTemplateTwo", identity: "Mock.Foo.2").WithDescription("Mock Foo template two");
ITemplateInfo sourceOneTemplateThree = new MockTemplateInfo("bar1", name: "MockBarTemplateOne", identity: "Mock.Bar.1").WithDescription("Mock Bar template one");
var packOne = (_fooPackInfo, (IReadOnlyList <ITemplateInfo>) new[] { sourceOneTemplateOne, sourceOneTemplateTwo });
var packTwo = (_barPackInfo, new[] { sourceOneTemplateThree });
dataForSources["source one"] = new[] { packOne, packTwo };
ITemplateInfo sourceTwoTemplateOne = new MockTemplateInfo("red", name: "MockRedTemplate", identity: "Mock.Red.1").WithDescription("Mock red template");
ITemplateInfo sourceTwoTemplateTwo = new MockTemplateInfo("blue", name: "MockBlueTemplate", identity: "Mock.Blue.1").WithDescription("Mock blue template");
ITemplateInfo sourceTwoTemplateThree = new MockTemplateInfo("green", name: "MockGreenTemplate", identity: "Mock.Green.1").WithDescription("Mock green template");
var red = (_redPackInfo, (IReadOnlyList <ITemplateInfo>) new[] { sourceTwoTemplateOne });
var blue = (_bluePackInfo, new[] { sourceTwoTemplateTwo });
var green = (_greenPackInfo, new[] { sourceTwoTemplateThree });
dataForSources["source two"] = new[] { red, blue, green };
return(dataForSources);
}
public void ChoiceValueCaseDifferenceIsAMatchTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, string>()
{
{ "foo", "Foo value" },
{ "bar", "Bar value" }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "FOO");
Assert.Equal("foo", canonical);
}
public void CanCompleteTypes()
{
var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithTag("type", "project");
var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group")
.WithTag("type", "solution");
var templateGroups = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>()));
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($" new foo --type ");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
Assert.NotNull(completionContext);
var result = InstantiateCommand.GetTemplateCompletions(args, templateGroups, settings, packageManager, completionContext !).Select(l => l.Label);
Assert.Equal(new[] { "project", "solution" }, result);
}
public void AmbiguousStartsWithValueHasNullCanonicalValueTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, ParameterChoice>()
{
{ "foo", new ParameterChoice("Foo", "Foo value") },
{ "bar", new ParameterChoice("Bar", "Bar value") },
{ "foot", new ParameterChoice("Foot", "Foot value") }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "f");
Assert.Null(canonical);
}
public void InvalidChoiceValueForParameterHasNullCanonicalValueTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, string>()
{
{ "foo", "Foo value" },
{ "bar", "Bar value" }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "whatever");
Assert.Null(canonical);
}
internal void CanParseAllowScriptsOption(string command, AllowRunScripts?result)
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithPostActions(ProcessStartPostActionProcessor.ActionProcessorId);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
Parser parser = ParserFactory.CreateParser(templateCommand);
ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>());
TemplateCommandArgs templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
Assert.Equal(result, templateArgs.AllowScripts);
}
internal void Create_CanDetectParseErrorsChoiceTemplateOptions(
string command,
string parameterName,
string parameterValues,
bool isRequired,
string?defaultValue,
string?defaultIfNoOptionValue,
string expectedError)
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithChoiceParameter(parameterName, parameterValues.Split("|"), isRequired, defaultValue, defaultIfNoOptionValue);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($" new create {command}");
var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
Parser parser = ParserFactory.CreateParser(templateCommand);
ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>());
Assert.True(templateParseResult.Errors.Any());
Assert.Equal(expectedError, templateParseResult.Errors.Single().Message);
}
internal void CanParseMultiChoiceTemplateOptions(string command, string parameterName, string parameterValues, string?defaultIfNoOptionValue, string?expectedValue)
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithChoiceParameter(parameterName, parameterValues.Split("|"), defaultIfNoOptionValue: defaultIfNoOptionValue, allowMultipleValues: true);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($" new {command}");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
Parser parser = ParserFactory.CreateParser(templateCommand);
ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>());
var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
if (string.IsNullOrWhiteSpace(expectedValue))
{
Assert.False(templateArgs.TemplateParameters.ContainsKey(parameterName));
}
else
{
Assert.True(templateArgs.TemplateParameters.ContainsKey(parameterName));
Assert.Equal(expectedValue, templateArgs.TemplateParameters[parameterName]);
}
}
public void ChoiceValueCaseDifferencesContributeToAmbiguousMatchTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, ParameterChoice>()
{
{ "foot", new ParameterChoice("Foo", "Foo value") },
{ "bar", new ParameterChoice("Bar", "Bar value") },
{ "Football", new ParameterChoice("Football", "Foo value") },
{ "FOOTPOUND", new ParameterChoice("Footpound", "Foo value") }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "foo");
Assert.Null(canonical);
}
public void ValidChoiceForParameterIsItsOwnCanonicalValueTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = new Dictionary <string, ParameterChoice>()
{
{ "foo", new ParameterChoice("Foo", "Foo value") },
{ "bar", new ParameterChoice("Bar", "Bar value") }
}
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "TestName", "foo");
Assert.Equal("foo", canonical);
}
public void TypeMismatch_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo templateMatchInfo = new TemplateMatchInfo(templateInfo);
templateMatchInfo.AddMatchDisposition(new MatchInfo(MatchInfo.BuiltIn.Type, "test", MatchKind.Mismatch));
Assert.False(WellKnownSearchFilters.MatchesAllCriteria(templateMatchInfo));
Assert.False(WellKnownSearchFilters.MatchesAtLeastOneCriteria(templateMatchInfo));
}
public void NamePartialMatch_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo templateMatchInfo = new TemplateMatchInfo(templateInfo);
templateMatchInfo.AddMatchDisposition(new MatchInfo(MatchInfo.BuiltIn.Name, "test", MatchKind.Partial));
Assert.True(WellKnownSearchFilters.MatchesAllCriteria(templateMatchInfo));
Assert.True(WellKnownSearchFilters.MatchesAtLeastOneCriteria(templateMatchInfo));
}
public void EmptyMatchDisposition_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo templateMatchInfo = new TemplateMatchInfo(templateInfo);
Assert.False(WellKnownSearchFilters.MatchesAllCriteria(templateMatchInfo));
Assert.False(WellKnownSearchFilters.MatchesAtLeastOneCriteria(templateMatchInfo));
Assert.Empty(templateMatchInfo.GetInvalidParameterNames());
Assert.Equal(0, templateMatchInfo.GetValidTemplateParameters().Count);
}
public void TypeMatch_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo templateMatchInfo = new TemplateMatchInfo(templateInfo);
templateMatchInfo.AddMatchDisposition(new MatchInfo(MatchInfo.BuiltIn.Type, "test", MatchKind.Exact));
Assert.True(WellKnownSearchFilters.MatchesAllCriteria(templateMatchInfo));
Assert.True(WellKnownSearchFilters.MatchesAtLeastOneCriteria(templateMatchInfo));
Assert.True(templateMatchInfo.IsInvokableMatch());
Assert.False(templateMatchInfo.HasAmbiguousParameterValueMatch());
}
public void TagFilterTests_TemplateWithoutTags(string testTag, MatchKind?kind)
{
MockTemplateInfo template = new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithBaselineInfo("app", "standard");
var filter = WellKnownSearchFilters.ClassificationFilter(testTag);
MatchInfo?result = filter(template);
Assert.Equal(kind, result?.Kind);
}
private string GenerateLocalCache()
{
ITemplatePackageInfo packOneInfo = new MockTemplatePackageInfo("PackOne", "1.0.0");
ITemplatePackageInfo packTwoInfo = new MockTemplatePackageInfo("PackTwo", "1.6.0");
ITemplatePackageInfo packThreeInfo = new MockTemplatePackageInfo("PackThree", "2.1");
ITemplateInfo fooOneTemplate =
new MockTemplateInfo("foo1", name: "MockFooTemplateOne", identity: "Mock.Foo.1", groupIdentity: "Mock.Foo", author: "TestAuthor")
.WithClassifications("CSharp", "Library")
.WithDescription("Mock Foo template one")
.WithChoiceParameter("Framework", "netcoreapp3.0", "netcoreapp3.1")
.WithTag("language", "C#")
.WithTag("type", "project");
ITemplateInfo fooTwoTemplate =
new MockTemplateInfo("foo2", name: "MockFooTemplateTwo", identity: "Mock.Foo.2", groupIdentity: "Mock.Foo")
.WithClassifications("CSharp", "Console")
.WithDescription("Mock Foo template two")
.WithChoiceParameter("Framework", "netcoreapp2.0", "netcoreapp2.1", "netcoreapp3.1")
.WithTag("language", "C#");
ITemplateInfo barCSharpTemplate =
new MockTemplateInfo("barC", name: "MockBarCsharpTemplate", identity: "Mock.Bar.1.Csharp", groupIdentity: "Mock.Bar")
.WithClassifications("CSharp")
.WithDescription("Mock Bar CSharp template")
.WithTag("language", "C#");
ITemplateInfo barFSharpTemplate =
new MockTemplateInfo("barF", name: "MockBarFSharpTemplate", identity: "Mock.Bar.1.FSharp", groupIdentity: "Mock.Bar")
.WithClassifications("FSharp")
.WithDescription("Mock Bar FSharp template")
.WithTag("language", "F#");
var fooOneTemplateData = new TemplateSearchData(fooOneTemplate);
var fooTwoTemplateData = new TemplateSearchData(fooTwoTemplate);
var barCSharpTemplateData = new TemplateSearchData(barCSharpTemplate);
var barFSharpTemplateData = new TemplateSearchData(barFSharpTemplate);
var packOne = new TemplatePackageSearchData(packOneInfo, new[] { fooOneTemplateData });
var packTwo = new TemplatePackageSearchData(packTwoInfo, new[] { fooTwoTemplateData });
var packThree = new TemplatePackageSearchData(packThreeInfo, new[] { barCSharpTemplateData, barFSharpTemplateData });
var cache = new TemplateSearchCache(new[] { packOne, packTwo, packThree });
string targetPath = Path.Combine(TestUtils.CreateTemporaryFolder(), "searchCacheV2.json");
File.WriteAllText(targetPath, cache.ToJObject().ToString());
return(targetPath);
}
public void CanIgnoreTemplateGroupsWithConstraints()
{
var template1 = new MockTemplateInfo("foo1", identity: "foo.1")
.WithConstraints(new TemplateConstraintInfo("test", "yes"));
var template2 = new MockTemplateInfo("foo2", identity: "foo.2")
.WithConstraints(new TemplateConstraintInfo("test", "no"));
var template3 = new MockTemplateInfo("foo3", identity: "foo.3")
.WithConstraints(new TemplateConstraintInfo("test", "bad-params"));
var templateGroups = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template1, template2, template3 }, A.Fake <IHostSpecificDataLoader>()));
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: new[] { (typeof(ITemplateConstraintFactory), (IIdentifiedComponent) new TestConstraintFactory("test")) });
public void TagFilterTests_TemplateWithTags(string templateTags, string testTag, MatchKind?kind)
{
const string separator = "||";
var templateTagsArray = templateTags.Split(new[] { separator }, System.StringSplitOptions.None);
MockTemplateInfo template = new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithBaselineInfo("app", "standard")
.WithClassifications(templateTagsArray);
var filter = WellKnownSearchFilters.ClassificationFilter(testTag);
MatchInfo?result = filter(template);
Assert.Equal(kind, result?.Kind);
}
public void EmptyMatchDisposition_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo TemplateMatchInfo = new TemplateMatchInfo(templateInfo);
Assert.False(TemplateMatchInfo.IsMatch);
Assert.False(TemplateMatchInfo.IsMatchExceptContext());
Assert.False(TemplateMatchInfo.IsPartialMatch);
Assert.False(TemplateMatchInfo.IsPartialMatchExceptContext());
Assert.False(TemplateMatchInfo.IsInvokableMatch());
Assert.False(TemplateMatchInfo.HasAmbiguousParameterValueMatch());
Assert.False(TemplateMatchInfo.HasParameterMismatch());
Assert.False(TemplateMatchInfo.HasParseError());
Assert.Equal(0, TemplateMatchInfo.GetInvalidParameterNames().Count);
Assert.Equal(0, TemplateMatchInfo.GetValidTemplateParameters().Count);
}
public Task CannotCreateCommandForInvalidParameter()
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithParameters("have:colon", "n1", "n2");
var paramSymbolInfo = new Dictionary <string, string>()
{
{ "longName", "name" },
{ "shortName", "n" }
};
var symbolInfo = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
{ "n1", paramSymbolInfo },
{ "n2", paramSymbolInfo }
};
var hostDataLoader = A.Fake <IHostSpecificDataLoader>();
A.CallTo(() => hostDataLoader.ReadHostSpecificTemplateData(template)).Returns(new HostSpecificTemplateData(symbolInfo));
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, hostDataLoader))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($" new foo");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
try
{
_ = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
}
catch (InvalidTemplateParametersException e)
{
Assert.Equal(2, e.ParameterErrors.Count);
Assert.Equal(templateGroup.Templates.Single(), e.Template);
return(Verifier.Verify(e.Message, _verifySettings.Settings));
}
Assert.True(false, "should not land here");
return(Task.FromResult(1));
}
public void ContextMatch_ReportsCorrectly()
{
ITemplateInfo templateInfo = new MockTemplateInfo();
ITemplateMatchInfo TemplateMatchInfo = new TemplateMatchInfo(templateInfo);
TemplateMatchInfo.AddDisposition(new MatchInfo {
Location = MatchLocation.Context, Kind = MatchKind.Exact
});
Assert.True(TemplateMatchInfo.IsMatch);
Assert.False(TemplateMatchInfo.IsMatchExceptContext());
Assert.True(TemplateMatchInfo.IsPartialMatch);
Assert.False(TemplateMatchInfo.IsPartialMatchExceptContext());
Assert.True(TemplateMatchInfo.IsInvokableMatch());
Assert.False(TemplateMatchInfo.HasAmbiguousParameterValueMatch());
Assert.False(TemplateMatchInfo.HasParameterMismatch());
Assert.False(TemplateMatchInfo.HasParseError());
}
private static IReadOnlyDictionary <string, IReadOnlyList <ITemplateNameSearchResult> > GetMockNameSearchResults()
{
Dictionary <string, IReadOnlyList <ITemplateNameSearchResult> > dataForSources = new Dictionary <string, IReadOnlyList <ITemplateNameSearchResult> >();
List <TemplateNameSearchResult> sourceOneResults = new List <TemplateNameSearchResult>();
ITemplateInfo sourceOneTemplateOne = new MockTemplateInfo("foo1", name: "MockFooTemplateOne", identity: "Mock.Foo.1").WithDescription("Mock Foo template one");
TemplateNameSearchResult sourceOneResultOne = new TemplateNameSearchResult(sourceOneTemplateOne, _fooPackInfo);
sourceOneResults.Add(sourceOneResultOne);
ITemplateInfo sourceOneTemplateTwo = new MockTemplateInfo("foo2", name: "MockFooTemplateTwo", identity: "Mock.Foo.2").WithDescription("Mock Foo template two");
TemplateNameSearchResult sourceOneResultTwo = new TemplateNameSearchResult(sourceOneTemplateTwo, _fooPackInfo);
sourceOneResults.Add(sourceOneResultTwo);
ITemplateInfo sourceOneTemplateThree = new MockTemplateInfo("bar1", name: "MockBarTemplateOne", identity: "Mock.Bar.1").WithDescription("Mock Bar template one");
TemplateNameSearchResult sourceOneResultThree = new TemplateNameSearchResult(sourceOneTemplateThree, _barPackInfo);
sourceOneResults.Add(sourceOneResultThree);
dataForSources["source one"] = sourceOneResults;
List <TemplateNameSearchResult> sourceTwoResults = new List <TemplateNameSearchResult>();
ITemplateInfo sourceTwoTemplateOne = new MockTemplateInfo("red", name: "MockRedTemplate", identity: "Mock.Red.1").WithDescription("Mock red template");
TemplateNameSearchResult sourceTwoResultOne = new TemplateNameSearchResult(sourceTwoTemplateOne, _redPackInfo);
sourceTwoResults.Add(sourceTwoResultOne);
ITemplateInfo sourceTwoTemplateTwo = new MockTemplateInfo("blue", name: "MockBlueTemplate", identity: "Mock.Blue.1").WithDescription("Mock blue template");
TemplateNameSearchResult sourceTwoResultTwo = new TemplateNameSearchResult(sourceTwoTemplateTwo, _bluePackInfo);
sourceTwoResults.Add(sourceTwoResultTwo);
ITemplateInfo sourceTwoTemplateThree = new MockTemplateInfo("green", name: "MockGreenTemplate", identity: "Mock.Green.1").WithDescription("Mock green template");
TemplateNameSearchResult sourceTwoResultThree = new TemplateNameSearchResult(sourceTwoTemplateThree, _greenPackInfo);
sourceTwoResults.Add(sourceTwoResultThree);
dataForSources["source two"] = sourceTwoResults;
return(dataForSources);
}
#pragma warning restore SA1117 // Parameters should be on same line or separate lines
public void CanShowTemplateDescription(string name, string?language, string?author, string?description, string expected)
{
MockTemplateInfo templateInfo = new MockTemplateInfo(
"console2",
name: name,
identity: "Console.App2",
author: author);
templateInfo.WithDescription(description);
if (language != null)
{
templateInfo.WithTag("language", language);
}
CliTemplateInfo cliTemplateInfo = new CliTemplateInfo(templateInfo, HostSpecificTemplateData.Default);
StringWriter sw = new StringWriter();
InstantiateCommand.ShowTemplateDetailHeaders(cliTemplateInfo, sw);
Assert.Equal(expected, sw.ToString());
}
public Task CanShowHintsForOtherTemplates()
{
var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("language", "Lang1").WithTag("type", "project");
var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group").WithTag("language", "Lang2").WithTag("type", "item");
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
ParseResult parseResult = myCommand.Parse("new -h");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
StringWriter sw = new StringWriter();
InstantiateCommand.ShowHintForOtherTemplates(templateGroup, templateGroup.Templates[0], args, sw);
return(Verifier.Verify(sw.ToString(), _verifySettings.Settings));
}
public void UnknownParameterNameHasNullCanonicalValueTest()
{
ITemplateParameter param = new MockParameter()
{
Name = "TestName",
Choices = null
};
IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>()
{
param
};
ITemplateInfo template = new MockTemplateInfo()
{
Parameters = parametersForTemplate
};
string canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(template, "OtherName", "whatever");
Assert.Null(canonical);
}
internal void Create_CanEvaluateTemplateWithSubcommandShortName(string command, string?expectedIdentitiesStr)
{
MockTemplateInfo template = new MockTemplateInfo(command, identity: $"{command}Template");
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
string[] expectedIdentities = expectedIdentitiesStr?.Split("|") ?? Array.Empty <string>();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($"new create {command}");
var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup);
Assert.Equal(expectedIdentities.Count(), templateCommands.Count);
Assert.Equal(expectedIdentities.OrderBy(s => s), templateCommands.Select(templateCommand => templateCommand.Template.Identity).OrderBy(s => s));
}
public void CanShowCommandOptions_NoOptions()
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("type", "MyType");
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
StringWriter sw = new StringWriter();
HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw);
InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext);
Assert.Equal($"Template options:{Environment.NewLine} (No options){Environment.NewLine}", sw.ToString());
}
public Task CanShowCommandOptions_Basic()
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group");
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
StringWriter sw = new StringWriter();
HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw);
InstantiateCommand.ShowCommandOptions(new[] { templateCommand }, templateCommand, helpContext);
return(Verifier.Verify(sw.ToString(), _verifySettings.Settings));
}
