public void InstantiateTemplate(string targetBaseDir, IParameterSet parameters = null, IVariableCollection variables = null)
{
if (parameters == null)
{
parameters = new MockParameterSet();
}
if (variables == null)
{
variables = new VariableCollection();
}
IRunnableProjectConfig runnableConfig = TemplateConfigTestHelpers.ConfigFromSource(_environment, SourceMountPoint);
IFileSystemInfo configFileInfo = TemplateConfigTestHelpers.ConfigFileSystemInfo(SourceMountPoint, _configFile);
runnableConfig.Evaluate(parameters, variables, configFileInfo);
MockGlobalRunSpec runSpec = new MockGlobalRunSpec();
runSpec.RootVariableCollection = variables;
IDirectory sourceDir = SourceMountPoint.DirectoryInfo("/");
IOrchestrator2 basicOrchestrator = new Core.Util.Orchestrator();
RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator);
foreach (FileSourceMatchInfo source in runnableConfig.Sources)
{
TemplateConfigTestHelpers.SetupFileSourceMatchersOnGlobalRunSpec(runSpec, source);
string targetDirForSource = Path.Combine(targetBaseDir, source.Target);
orchestrator.Run(runSpec, sourceDir, targetDirForSource);
}
}
public void EvaluateNowConfig()
{
string variableName = "nowString";
string format = "";
bool utc = true;
NowMacroConfig macroConfig = new NowMacroConfig(variableName, format, utc);
Assert.Equal("string", macroConfig.DataType);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
NowMacro macro = new NowMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
Assert.IsType <string>(parameters.ResolvedValues[resultParam]);
string macroNowString = (string)parameters.ResolvedValues[resultParam];
DateTime macroNowTime = Convert.ToDateTime(macroNowString);
TimeSpan difference = macroNowTime.Subtract(DateTime.UtcNow);
// 10 seconds is quite a lot of wiggle room, but should be fine, and safe.
Assert.True(difference.TotalSeconds < 10);
}
public void TestRegexMatchMacroFalse()
{
const string variableName = "isMatch";
const string sourceVariable = "originalValue";
RegexMatchMacroConfig macroConfig = new RegexMatchMacroConfig(variableName, null, sourceVariable, @"(((?<=\.)|^)(?=\d)|[^\w\.])");
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new RunnableProjectGenerator.ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
const string sourceValue = "A1234test";
const bool expectedValue = false;
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
RegexMatchMacro macro = new RegexMatchMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
Assert.True(parameters.TryGetParameterDefinition(variableName, out ITemplateParameter newParam));
bool newValue = (bool)parameters.ResolvedValues[newParam];
Assert.Equal(newValue, expectedValue);
}
public void EvaluateNowDeferredConfig()
{
string variableName = "nowString";
string format = "";
bool utc = false;
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("format", format);
jsonParameters.Add("utc", utc);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("NowMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
NowMacro macro = new NowMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
Assert.Equal("string", (realConfig as NowMacroConfig)?.DataType);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
Assert.IsType <string>(parameters.ResolvedValues[resultParam]);
string macroNowString = (string)parameters.ResolvedValues[resultParam];
DateTime macroNowTime = Convert.ToDateTime(macroNowString);
TimeSpan difference = macroNowTime.Subtract(DateTime.Now);
// 10 seconds is quite a lot of wiggle room, but should be fine, and safe.
Assert.True(difference.TotalSeconds < 10);
}
public void TestConstantDeferredConfig()
{
string variableName = "myConstant";
string value = "1048576";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("value", value);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("ConstantMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
ConstantMacro macro = new ConstantMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter constParameter;
Assert.True(parameters.TryGetParameterDefinition(variableName, out constParameter));
string constParamValue = (parameters.ResolvedValues[constParameter]).ToString();
Assert.Equal(constParamValue, value);
}
public void TestDefaultFormatIsCaseSensetive()
{
string paramNameLower = "TestGuidLower";
IMacroConfig macroConfigLower = new GuidMacroConfig(paramNameLower, "string", string.Empty, "n");
string paramNameUpper = "TestGuidUPPER";
IMacroConfig macroConfigUpper = new GuidMacroConfig(paramNameUpper, "string", string.Empty, "N");
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
GuidMacro guidMacro = new GuidMacro();
guidMacro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfigLower, parameters, setter);
guidMacro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfigUpper, parameters, setter);
Assert.True(parameters.TryGetParameterDefinition(paramNameLower, out var setParamLower));
Assert.All(((string)parameters.ResolvedValues[setParamLower]).ToCharArray(), (c) =>
{
Assert.True(char.IsLower(c) || char.IsDigit(c));
});
Assert.True(parameters.TryGetParameterDefinition(paramNameUpper, out var setParamUpper));
Assert.All(((string)parameters.ResolvedValues[setParamUpper]).ToCharArray(), (c) =>
{
Assert.True(char.IsUpper(c) || char.IsDigit(c));
});
}
public Task Create(ITemplate template, IParameterSet parameters)
{
RunnableProjectTemplate tmplt = (RunnableProjectTemplate)template;
RunnableProjectOrchestrator o = new RunnableProjectOrchestrator();
GlobalRunSpec configRunSpec = new GlobalRunSpec(new FileSource(), tmplt.ConfigFile.Parent, parameters, tmplt.Config.Config, tmplt.Config.Special);
IOperationProvider[] providers = configRunSpec.Operations.ToArray();
foreach (KeyValuePair <IPathMatcher, IRunSpec> special in configRunSpec.Special)
{
if (special.Key.IsMatch(".netnew.json"))
{
providers = special.Value.GetOperations(providers).ToArray();
break;
}
}
IRunnableProjectConfig m = tmplt.Config.ReprocessWithParameters(parameters, configRunSpec.RootVariableCollection, tmplt.ConfigFile, providers);
foreach (FileSource source in m.Sources)
{
GlobalRunSpec runSpec = new GlobalRunSpec(source, tmplt.ConfigFile.Parent, parameters, m.Config, m.Special);
string target = Path.Combine(Directory.GetCurrentDirectory(), source.Target);
o.Run(runSpec, tmplt.ConfigFile.Parent.GetDirectoryAtRelativePath(source.Source), target);
}
return(Task.FromResult(true));
}
public Task <ICreationResult> CreateAsync(
IEngineEnvironmentSettings environmentSettings,
IRunnableProjectConfig runnableProjectConfig,
IDirectory templateSourceRoot,
IParameterSet parameters,
string targetDirectory,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ProcessMacros(environmentSettings, runnableProjectConfig.OperationConfig, parameters);
IVariableCollection variables = SetupVariables(environmentSettings, parameters, runnableProjectConfig.OperationConfig.VariableSetup);
runnableProjectConfig.Evaluate(parameters, variables);
IOrchestrator basicOrchestrator = new Core.Util.Orchestrator(environmentSettings.Host.Logger, environmentSettings.Host.FileSystem);
RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator);
GlobalRunSpec runSpec = new GlobalRunSpec(templateSourceRoot, environmentSettings.Components, parameters, variables, runnableProjectConfig.OperationConfig, runnableProjectConfig.SpecialOperationConfig, runnableProjectConfig.IgnoreFileNames);
foreach (FileSourceMatchInfo source in runnableProjectConfig.Sources)
{
runSpec.SetupFileSource(source);
string target = Path.Combine(targetDirectory, source.Target);
orchestrator.Run(runSpec, templateSourceRoot.DirectoryInfo(source.Source), target);
}
return(Task.FromResult(GetCreationResult(environmentSettings.Host.Logger, runnableProjectConfig, variables)));
}
public RunnableProjectTemplate(JObject raw, IGenerator generator, IFile configFile, IRunnableProjectConfig config, IFile localeConfigFile, IFile hostConfigFile)
{
config.SourceFile = configFile;
ConfigFile = configFile;
Generator = generator;
Source = configFile.MountPoint;
Config = config;
DefaultName = config.DefaultName;
Name = config.Name;
Identity = config.Identity ?? config.Name;
ShortName = config.ShortName;
Author = config.Author;
Tags = config.Tags ?? new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase);
CacheParameters = config.CacheParameters ?? new Dictionary <string, ICacheParameter>(StringComparer.OrdinalIgnoreCase);
Description = config.Description;
Classifications = config.Classifications;
GroupIdentity = config.GroupIdentity;
Precedence = config.Precedence;
LocaleConfigFile = localeConfigFile;
IsNameAgreementWithFolderPreferred = raw.ToBool("preferNameDirectory", false);
HostConfigMountPointId = hostConfigFile?.MountPoint?.Info?.MountPointId ?? Guid.Empty;
HostConfigPlace = hostConfigFile?.FullPath;
ThirdPartyNotices = raw.ToString("thirdPartyNotices");
_raw = raw;
BaselineInfo = config.BaselineInfo;
HasScriptRunningPostActions = config.HasScriptRunningPostActions;
}
public void TestCaseChangeToUpperConfig()
{
string variableName = "myString";
string sourceVariable = "sourceString";
bool toLower = false;
CaseChangeMacroConfig macroConfig = new CaseChangeMacroConfig(variableName, null, sourceVariable, toLower);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
string sourceValue = "Original Value SomethingCamelCase";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
CaseChangeMacro macro = new CaseChangeMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter convertedParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
Assert.Equal(convertedValue, sourceValue.ToUpper());
}
public void TestSwitchConfig()
{
string variableName = "mySwitchVar";
string evaluator = "C++";
string dataType = "string";
string expectedValue = "this one";
IList <KeyValuePair <string, string> > switches = new List <KeyValuePair <string, string> >();
switches.Add(new KeyValuePair <string, string>("(3 > 10)", "three greater than ten - false"));
switches.Add(new KeyValuePair <string, string>("(false)", "false value"));
switches.Add(new KeyValuePair <string, string>("(10 > 0)", expectedValue));
switches.Add(new KeyValuePair <string, string>("(5 > 4)", "not this one"));
SwitchMacroConfig macroConfig = new SwitchMacroConfig(variableName, evaluator, dataType, switches);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
SwitchMacro macro = new SwitchMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
string resultValue = (string)parameters.ResolvedValues[resultParam];
Assert.Equal(resultValue, expectedValue);
}
public IReadOnlyDictionary <string, IReadOnlyList <IFileChange2> > GetFileChanges(string targetBaseDir, IParameterSet parameters = null, IVariableCollection variables = null)
{
if (parameters == null)
{
parameters = new MockParameterSet();
}
if (variables == null)
{
variables = new VariableCollection();
}
IRunnableProjectConfig runnableConfig = TemplateConfigTestHelpers.ConfigFromSource(_environment, SourceMountPoint);
IFileSystemInfo configFileInfo = TemplateConfigTestHelpers.ConfigFileSystemInfo(SourceMountPoint, _configFile);
runnableConfig.Evaluate(parameters, variables, configFileInfo);
MockGlobalRunSpec runSpec = new MockGlobalRunSpec();
IDirectory sourceDir = SourceMountPoint.DirectoryInfo("/");
IOrchestrator2 basicOrchestrator = new Core.Util.Orchestrator();
RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator);
Dictionary <string, IReadOnlyList <IFileChange2> > changesByTarget = new Dictionary <string, IReadOnlyList <IFileChange2> >();
foreach (FileSourceMatchInfo source in runnableConfig.Sources)
{
TemplateConfigTestHelpers.SetupFileSourceMatchersOnGlobalRunSpec(runSpec, source);
string targetDirForSource = Path.Combine(targetBaseDir, source.Target);
IReadOnlyList <IFileChange2> changes = orchestrator.GetFileChanges(runSpec, sourceDir, targetDirForSource);
changesByTarget[source.Target] = changes;
}
return(changesByTarget);
}
public void TestRandomDeferredConfig(int low, int?high)
{
string variableName = "myRnd";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("low", low);
if (high.HasValue)
{
jsonParameters.Add("high", high);
}
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("RandomMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
RandomMacro macro = new RandomMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter valueParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out valueParam));
long randomValue = (long)parameters.ResolvedValues[valueParam];
Assert.True(randomValue >= low);
if (high.HasValue)
{
Assert.True(randomValue <= high);
}
}
public void TestRandomConfig(int low, int?high)
{
string variableName = "myRnd";
RandomMacroConfig macroConfig = new RandomMacroConfig(variableName, null, low, high);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
RandomMacro macro = new RandomMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter valueParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out valueParam));
long randomValue = (long)parameters.ResolvedValues[valueParam];
Assert.True(randomValue >= low);
if (high.HasValue)
{
Assert.True(randomValue <= high);
}
}
public ParameterSet(IRunnableProjectConfig config)
{
foreach (KeyValuePair <string, Parameter> p in config.Parameters)
{
p.Value.Name = p.Key;
_parameters[p.Key] = p.Value;
}
}
// 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 void TestSwitchDeferredConfig()
{
string variableName = "mySwitchVar";
string evaluator = "C++";
string dataType = "string";
string expectedValue = "this one";
string switchCases = @"[
{
'condition': '(3 > 10)',
'value': 'three greater than ten'
},
{
'condition': '(false)',
'value': 'false value'
},
{
'condition': '(10 > 0)',
'value': '" + expectedValue + @"'
},
{
'condition': '(5 > 4)',
'value': 'not this one'
}
]";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("evaluator", evaluator);
jsonParameters.Add("datatype", dataType);
jsonParameters.Add("cases", JArray.Parse(switchCases));
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("SwitchMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
SwitchMacro macro = new SwitchMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
string resultValue = (string)parameters.ResolvedValues[resultParam];
Assert.Equal(resultValue, expectedValue);
}
public void TestGuidConfig()
{
string paramName = "TestGuid";
IMacroConfig macroConfig = new GuidMacroConfig(paramName, "string", string.Empty, null);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
GuidMacro guidMacro = new GuidMacro();
guidMacro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ValidateGuidMacroCreatedParametersWithResolvedValues(paramName, parameters);
}
public void TestRegexDeferredConfig()
{
string variableName = "myRegex";
string sourceVariable = "originalValue";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("source", sourceVariable);
string jsonSteps = @"[
{
'regex': 'A',
'replacement': 'Z'
}
]";
jsonParameters.Add("steps", JArray.Parse(jsonSteps));
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("RegexMacro", "string", variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
string sourceValue = "ABCAABBCC";
string expectedValue = "ZBCZZBBCC";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
RegexMacro macro = new RegexMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter newParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out newParam));
string newValue = (string)parameters.ResolvedValues[newParam];
Assert.Equal(newValue, expectedValue);
}
public RunnableProjectTemplate(JObject raw, IGenerator generator, IFile configFile, IRunnableProjectConfig config)
{
config.SourceFile = configFile;
ConfigFile = configFile;
Generator = generator;
Source = configFile.MountPoint;
Config = config;
DefaultName = config.DefaultName;
Name = config.Name;
Identity = config.Identity ?? config.Name;
ShortName = config.ShortName;
Author = config.Author;
Tags = config.Tags;
Classifications = config.Classifications;
GroupIdentity = config.GroupIdentity;
_raw = raw;
}
public void TestJoinConstantAndReferenceSymbolConfig(string separator, bool removeEmptyValues)
{
string variableName = "joinedParameter";
string referenceSymbolName = "referenceSymbol";
string referenceSymbolValue = "referenceValue";
string referenceEmptySymbolName = "referenceEmptySymbol";
string constantValue = "constantValue";
List <KeyValuePair <string, string> > definitions = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("const", constantValue),
new KeyValuePair <string, string>("ref", referenceEmptySymbolName),
new KeyValuePair <string, string>("ref", referenceSymbolName)
};
JoinMacroConfig macroConfig = new JoinMacroConfig(variableName, null, definitions, separator, removeEmptyValues);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new RunnableProjectGenerator.ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
Parameter referenceParam = new Parameter
{
IsVariable = true,
Name = referenceSymbolName
};
variables[referenceSymbolName] = referenceSymbolValue;
setter(referenceParam, referenceSymbolValue);
JoinMacro macro = new JoinMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
Assert.True(parameters.TryGetParameterDefinition(variableName, out ITemplateParameter convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
string expectedValue =
removeEmptyValues ?
string.Join(separator, constantValue, referenceSymbolValue) :
string.Join(separator, constantValue, null, referenceSymbolValue);
Assert.Equal(convertedValue, expectedValue);
}
public void TestDeferredJoinConfig(string separator)
{
string variableName = "joinedParameter";
string referenceSymbolName = "referenceSymbol";
string referenceSymbolValue = "referenceValue";
string constantValue = "constantValue";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
string symbols =
$"[ {{\"type\":\"const\" , \"value\":\"{constantValue}\" }}, {{\"type\":\"ref\" , \"value\":\"{referenceSymbolName}\" }} ]";
jsonParameters.Add("symbols", JArray.Parse(symbols));
if (!string.IsNullOrEmpty(separator))
{
jsonParameters.Add("separator", separator);
}
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("JoinMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new RunnableProjectGenerator.ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
Parameter referenceParam = new Parameter
{
IsVariable = true,
Name = referenceSymbolName
};
variables[referenceSymbolName] = referenceSymbolValue;
setter(referenceParam, referenceSymbolValue);
JoinMacro macro = new JoinMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
Assert.True(parameters.TryGetParameterDefinition(variableName, out ITemplateParameter convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
string expectedValue = string.Join(separator, constantValue, referenceSymbolValue);
Assert.Equal(convertedValue, expectedValue);
}
public void TestDeferredGuidConfig()
{
Dictionary <string, JToken?> jsonParameters = new();
jsonParameters.Add("format", null);
string variableName = "myGuid1";
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("GuidMacro", "string", variableName, jsonParameters);
GuidMacro guidMacro = new GuidMacro();
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
IMacroConfig realConfig = guidMacro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
guidMacro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ValidateGuidMacroCreatedParametersWithResolvedValues(variableName, parameters);
}
public void TestEvaluateConfig(string predicate, bool expectedResult)
{
string variableName = "myPredicate";
string evaluator = "C++";
EvaluateMacroConfig macroConfig = new EvaluateMacroConfig(variableName, null, predicate, evaluator);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
EvaluateMacro macro = new EvaluateMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
bool resultValue = (bool)parameters.ResolvedValues[resultParam];
Assert.Equal(resultValue, expectedResult);
}
public RunnableProjectTemplate(JObject raw, IGenerator generator, IFile configFile, IRunnableProjectConfig config, IFile localeConfigFile, IFile hostConfigFile)
{
config.SourceFile = configFile;
ConfigFile = configFile;
Generator = generator;
Source = configFile.MountPoint;
Config = config;
DefaultName = config.DefaultName;
Name = config.Name;
Identity = config.Identity ?? config.Name;
ShortName = config.ShortName;
Author = config.Author;
Tags = config.Tags;
Description = config.Description;
Classifications = config.Classifications;
GroupIdentity = config.GroupIdentity;
LocaleConfigFile = localeConfigFile;
IsNameAgreementWithFolderPreferred = raw.ToBool("preferNameDirectory", false);
HostConfigMountPointId = hostConfigFile?.MountPoint?.Info?.MountPointId ?? Guid.Empty;
HostConfigPlace = hostConfigFile?.FullPath;
_raw = raw;
}
public void TestConstantConfig()
{
string variableName = "myConstant";
string value = "1048576";
ConstantMacroConfig macroConfig = new ConstantMacroConfig(null, variableName, value);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
ConstantMacro macro = new ConstantMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter constParameter;
Assert.True(parameters.TryGetParameterDefinition(variableName, out constParameter));
string constParamValue = (parameters.ResolvedValues[constParameter]).ToString();
Assert.Equal(constParamValue, value);
}
public void TestRegexMacro()
{
string variableName = "myRegex";
string sourceVariable = "originalValue";
IList <KeyValuePair <string, string> > steps = new List <KeyValuePair <string, string> >();
steps.Add(new KeyValuePair <string, string>("2+", "3"));
steps.Add(new KeyValuePair <string, string>("13", "Z"));
RegexMacroConfig macroConfig = new RegexMacroConfig(variableName, null, sourceVariable, steps);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
string sourceValue = "QQQ121222112";
string expectedValue = "QQQZZ1Z";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
RegexMacro macro = new RegexMacro();
macro.EvaluateConfig(_engineEnvironmentSettings, variables, macroConfig, parameters, setter);
ITemplateParameter newParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out newParam));
string newValue = (string)parameters.ResolvedValues[newParam];
Assert.Equal(newValue, expectedValue);
}
public void TestDeferredCaseChangeConfig()
{
string variableName = "myString";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
string sourceVariable = "sourceString";
jsonParameters.Add("source", sourceVariable);
jsonParameters.Add("toLower", false);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("CaseChangeMacro", null, variableName, jsonParameters);
CaseChangeMacro macro = new CaseChangeMacro();
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
string sourceValue = "Original Value SomethingCamelCase";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter convertedParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
Assert.Equal(convertedValue, sourceValue.ToUpper());
}
private static ICreationResult GetCreationResult(ILogger logger, IRunnableProjectConfig runnableProjectConfig, IVariableCollection variables)
{
return(new CreationResult(
postActions: PostAction.ListFromModel(logger, runnableProjectConfig.PostActionModels, variables),
primaryOutputs: CreationPath.ListFromModel(logger, runnableProjectConfig.PrimaryOutputs, variables)));
}
