public async Task Evaluate_ArrayOfVersions(IReadOnlyList <string> workloads, bool allowed)
{
var config = new
{
identity = "test-constraint-01",
constraints = new
{
specVersions = new
{
type = "workload",
args = new[] { "workloadA", "workloadB" }
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IWorkloadsInfoProvider workloadInfoProvider = new WorkloadsInfoProviderMock(workloads); //A.Fake<IWorkloadsInfoProvider>();
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Components.OfType <IWorkloadsInfoProvider>()).Returns(new[] { workloadInfoProvider });
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new WorkloadConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
//A.CallTo(() => workloadInfoProvider
// .GetInstalledWorkloadsAsync(A<CancellationToken>._))
// .Returns(Task.FromResult(workloads.Select(s => new WorkloadInfo(s, $"D:{s}"))));
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(allowed ? TemplateConstraintResult.Status.Allowed : TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
}
public void CheckTemplateRootRelativeToInstallPath(string pathToTemplateJson, bool shouldAllPathsBeValid)
{
SimpleConfigModel baseConfig = SimpleConfigModel.FromJObject(JObject.Parse(BasicTemplateConfig));
RunnableProjectGenerator generator = new RunnableProjectGenerator();
string sourcePath = FileSystemHelpers.GetNewVirtualizedPath(_engineEnvironmentSettings);
IDictionary <string, string> templateSourceFiles = new Dictionary <string, string>();
templateSourceFiles.Add(pathToTemplateJson, BasicTemplateConfig);
TestTemplateSetup setup = new TestTemplateSetup(_engineEnvironmentSettings, sourcePath, templateSourceFiles);
setup.WriteSource();
IFile templateFile = setup.FileInfoForSourceFile(pathToTemplateJson);
RunnableProjectConfig templateModel = new RunnableProjectConfig(_engineEnvironmentSettings, generator, baseConfig, templateFile);
if (shouldAllPathsBeValid)
{
Assert.Empty(templateModel.ValidateTemplateSourcePaths());
}
else
{
Assert.NotEmpty(templateModel.ValidateTemplateSourcePaths());
}
}
public async void CreateAsyncTest_ConditionWithUnquotedChoiceLiteral(string templateConfig, string expectedResult)
{
//
// Template content preparation
//
string sourceSnippet = @"
//#if( ChoiceParam == FirstChoice )
FIRST
//#elseif (ChoiceParam == SecondChoice )
SECOND
//#elseif (ChoiceParam == ThirdChoice )
THIRD
//#else
UNKNOWN
//#endif
";
IDictionary <string, string?> templateSourceFiles = new Dictionary <string, string?>();
// template.json
templateSourceFiles.Add(TestFileSystemHelper.DefaultConfigRelativePath, templateConfig);
//content
templateSourceFiles.Add("sourcFile", sourceSnippet);
//
// Dependencies preparation and mounting
//
IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment();
string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment);
string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment);
TestFileSystemHelper.WriteTemplateSource(environment, sourceBasePath, templateSourceFiles);
IMountPoint?sourceMountPoint = TestFileSystemHelper.CreateMountPoint(environment, sourceBasePath);
RunnableProjectGenerator rpg = new RunnableProjectGenerator();
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(JObject.Parse(templateConfig));
IRunnableProjectConfig runnableConfig = new RunnableProjectConfig(environment, rpg, configModel, sourceMountPoint.FileInfo(TestFileSystemHelper.DefaultConfigRelativePath));
IParameterSet parameters = new ParameterSet(runnableConfig);
ITemplateParameter choiceParameter;
Assert.True(parameters.TryGetParameterDefinition("ChoiceParam", out choiceParameter), "ChoiceParam expected to be extracted from template config");
parameters.ResolvedValues[choiceParameter] = "SecondChoice";
IDirectory sourceDir = sourceMountPoint !.DirectoryInfo("/") !;
//
// Running the actual scenario: template files processing and generating output (including macros processing)
//
await rpg.CreateAsync(environment, runnableConfig, sourceDir, parameters, targetDir, CancellationToken.None);
//
// Veryfying the outputs
//
string resultContent = environment.Host.FileSystem.ReadAllText(Path.Combine(targetDir, "sourcFile")).Trim();
Assert.Equal(expectedResult, resultContent);
}
public async Task Evaluate_AlternativeInstalledVersions(string sdkVersion, IReadOnlyList <string> installedVersions, bool hasAlternativeInstalled)
{
var config = new
{
identity = "test-constraint-01",
constraints = new
{
specVersions = new
{
type = "sdk-version",
args = new[] { "1.2.3-*", "4.5.*" }
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
ISdkInfoProvider sdkInfoProvider = new SdkInfoProviderMock(sdkVersion, installedVersions); //A.Fake<ISdkInfoProvider>();
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Components.OfType <ISdkInfoProvider>()).Returns(new[] { sdkInfoProvider });
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new SdkVersionConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
Assert.StartsWith(
hasAlternativeInstalled
? "Sample CTA with alternatives"
: "Sample CTA without alternatives",
evaluateResult.CallToAction);
}
public void Evaluate_SingleVersionRange(string sdkVersion, bool allowed)
{
var config = new
{
identity = "test-constraint-01",
constraints = new
{
specVersions = new
{
type = "sdk-version",
args = "(1.2.3-*, 4.5]"
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
ISdkInfoProvider sdkInfoProvider = new SdkInfoProviderMock(sdkVersion); //A.Fake<ISdkInfoProvider>();
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Components.OfType <ISdkInfoProvider>()).Returns(new[] { sdkInfoProvider });
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new SdkVersionConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
//Workaround needed
//A.CallTo(() => sdkInfoProvider.GetVersionAsync(A<CancellationToken>._)).Returns(t);
var evaluateResult = constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).Result;
Assert.Equal(allowed ? TemplateConstraintResult.Status.Allowed : TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
}
public void CheckTemplateSourcesRelativeToTemplateRootMultipleDirsUnderMountPoint(bool shouldAllPathsBeValid, string source)
{
const string pathFromMountPointRootToTemplateRoot = "MountRoot/Stuff/TemplateRoot/";
string pathToTemplateConfig = pathFromMountPointRootToTemplateRoot + ".template.config/template.json";
string sourcePath = FileSystemHelpers.GetNewVirtualizedPath(EngineEnvironmentSettings);
IDictionary <string, string> templateSourceFiles = new Dictionary <string, string>();
string templateConfig = String.Format(TemplateConfigWithSourcePlaceholder, source);
templateSourceFiles.Add(pathToTemplateConfig, templateConfig);
string sampleContentDir = pathFromMountPointRootToTemplateRoot + "things/stuff/_._";
templateSourceFiles.Add(sampleContentDir, ""); // directories under the template root - valid source locations.
templateSourceFiles.Add("ExistingDir/_._", "");
templateSourceFiles.Add("MountRoot/Subdir/_._", "");
TestTemplateSetup setup = new TestTemplateSetup(EngineEnvironmentSettings, sourcePath, templateSourceFiles);
setup.WriteSource();
RunnableProjectGenerator generator = new RunnableProjectGenerator();
IFile templateFile = setup.FileInfoForSourceFile(pathToTemplateConfig);
JObject srcObject = generator.ReadJObjectFromIFile(templateFile);
SimpleConfigModel templateModel = SimpleConfigModel.FromJObject(templateFile.MountPoint.EnvironmentSettings, srcObject);
RunnableProjectTemplate runnableProjectTemplate = new RunnableProjectTemplate(srcObject, generator, templateFile, templateModel, null, null);
bool allPathsAreValid = generator.AreAllTemplatePathsValid(templateModel, runnableProjectTemplate);
Assert.Equal(shouldAllPathsBeValid, allPathsAreValid);
}
public async Task CanReadArrayConfiguration()
{
var config = new
{
identity = "test",
constraints = new
{
winOnly = new
{
type = "os",
args = new[] { "Windows", "Linux" }
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
var constraintManager = new TemplateConstraintManager(_sharedSettings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
var pass = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
Assert.Equal(pass, evaluateResult.EvaluationStatus == TemplateConstraintResult.Status.Allowed);
if (!pass)
{
Assert.Equal($"Running template on {RuntimeInformation.OSDescription} is not supported, supported OS is/are: {OSPlatform.Windows}, {OSPlatform.Linux}.", evaluateResult.LocalizedErrorMessage);
}
else
{
Assert.Null(evaluateResult.LocalizedErrorMessage);
}
Assert.Null(evaluateResult.CallToAction);
}
public async Task FailsOnWrongConfiguration()
{
var config = new
{
identity = "test",
constraints = new
{
host = new
{
type = "host",
args =
new
{
hostName = "host2",
version = "1.0.0"
}
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Host.HostIdentifier).Returns("host3");
A.CallTo(() => settings.Host.Version).Returns("2.0.0");
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new HostConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(TemplateConstraintResult.Status.NotEvaluated, evaluateResult.EvaluationStatus);
Assert.Equal("'{\"hostName\":\"host2\",\"version\":\"1.0.0\"}' is not a valid JSON array.", evaluateResult.LocalizedErrorMessage);
Assert.Equal("Check the constraint configuration in template.json.", evaluateResult.CallToAction);
}
public void UnknownFormNameForDerivedSymbolValueDoesNotThrow()
{
string templateJson = @"
{
""name"": ""TestTemplate"",
""identity"": ""TestTemplate"",
""symbols"": {
""original"": {
""type"": ""parameter"",
""replaces"": ""whatever"",
},
""myDerivedSym"": {
""type"": ""derived"",
""valueSource"": ""original"",
""valueTransform"": ""fakeForm"",
""replaces"": ""something""
}
}
}
";
JObject configObj = JObject.Parse(templateJson);
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(EngineEnvironmentSettings, configObj);
IGlobalRunConfig runConfig = null;
try
{
runConfig = ((IRunnableProjectConfig)configModel).OperationConfig;
}
catch
{
Assert.True(false, "Should not throw on unknown value form name");
}
Assert.NotNull(runConfig);
}
public void CheckTemplateSourcesRelativeToTemplateRootMultipleDirsUnderMountPoint(bool shouldAllPathsBeValid, string source)
{
string templateConfig = string.Format(TemplateConfigWithSourcePlaceholder, source);
SimpleConfigModel baseConfig = SimpleConfigModel.FromJObject(JObject.Parse(templateConfig));
RunnableProjectGenerator generator = new RunnableProjectGenerator();
const string pathFromMountPointRootToTemplateRoot = "MountRoot/Stuff/TemplateRoot/";
string pathToTemplateConfig = pathFromMountPointRootToTemplateRoot + ".template.config/template.json";
string sourcePath = FileSystemHelpers.GetNewVirtualizedPath(_engineEnvironmentSettings);
IDictionary <string, string> templateSourceFiles = new Dictionary <string, string>();
templateSourceFiles.Add(pathToTemplateConfig, templateConfig);
string sampleContentDir = pathFromMountPointRootToTemplateRoot + "things/stuff/_._";
templateSourceFiles.Add(sampleContentDir, ""); // directories under the template root - valid source locations.
templateSourceFiles.Add("ExistingDir/_._", "");
templateSourceFiles.Add("MountRoot/Subdir/_._", "");
TestTemplateSetup setup = new TestTemplateSetup(_engineEnvironmentSettings, sourcePath, templateSourceFiles);
setup.WriteSource();
IFile templateFile = setup.FileInfoForSourceFile(pathToTemplateConfig);
RunnableProjectConfig templateModel = new RunnableProjectConfig(_engineEnvironmentSettings, generator, baseConfig, templateFile);
if (shouldAllPathsBeValid)
{
Assert.Empty(templateModel.ValidateTemplateSourcePaths());
}
else
{
Assert.NotEmpty(templateModel.ValidateTemplateSourcePaths());
}
}
public void CanGenerateFileRenamesForSymbolBasedRenames_NonString()
{
//environment
IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment();
//simulate template files
string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment);
IDictionary <string, string?> templateSourceFiles = new Dictionary <string, string?>();
// template.json
templateSourceFiles.Add(TemplateConfigTestHelpers.DefaultConfigRelativePath, string.Empty);
// content
templateSourceFiles.Add("date_name.txt", null);
templateSourceFiles.Add("other_name.txt", null);
TestTemplateSetup setup = new TestTemplateSetup(environment, sourceBasePath, templateSourceFiles);
setup.WriteSource();
//get target directory
string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment);
//prepare parameters
ParameterSet parameters = new ParameterSet(SimpleConfigModel.FromJObject(environment, JObject.Parse("{}")));
Parameter nameParameter = new Parameter()
{
Name = "name"
};
Parameter intDateParameter = new Parameter()
{
Name = "date"
};
Parameter otherParameter = new Parameter()
{
Name = "other"
};
parameters.AddParameter(nameParameter);
parameters.AddParameter(intDateParameter);
parameters.AddParameter(otherParameter);
parameters.ResolvedValues[nameParameter] = "testName";
parameters.ResolvedValues[intDateParameter] = 20210429;
parameters.ResolvedValues[otherParameter] = new TestParameterValueClass {
A = "foo", B = "bar"
};
//prepare renames configuration
List <IReplacementTokens> symbolBasedRenames = new List <IReplacementTokens>();
symbolBasedRenames.Add(new ReplacementTokens("date", TokenConfig.FromValue("date")));
symbolBasedRenames.Add(new ReplacementTokens("other", TokenConfig.FromValue("other")));
symbolBasedRenames.Add(new ReplacementTokens("name", TokenConfig.FromValue("name")));
IReadOnlyDictionary <string, string> allChanges = setup.GetRenames("./", targetDir, parameters, symbolBasedRenames);
Assert.Equal(2, allChanges.Count);
Assert.Equal("20210429_testName.txt", allChanges["date_name.txt"]);
Assert.Equal("foo-bar_testName.txt", allChanges["other_name.txt"]);
}
public void CanGenerateFileRenamesForSymbolBasedRenames_WhenFormsResultInSameValue()
{
//environment
IEngineEnvironmentSettings environment = TemplateConfigTestHelpers.GetTestEnvironment();
//simulate template files
string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment);
IDictionary <string, string> templateSourceFiles = new Dictionary <string, string>();
// template.json
templateSourceFiles.Add(TemplateConfigTestHelpers.DefaultConfigRelativePath, String.Empty);
// content
templateSourceFiles.Add("replace1_file.txt", null);
templateSourceFiles.Add("replace2_file.txt", null);
TestTemplateSetup setup = new TestTemplateSetup(environment, sourceBasePath, templateSourceFiles);
setup.WriteSource();
//get target directory
string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment);
//prepare parameters
ParameterSet parameters = new ParameterSet(SimpleConfigModel.FromJObject(environment, JObject.Parse("{}")));
Parameter nameParameter = new Parameter()
{
Name = "name"
};
Parameter testParameterIdentity = new Parameter()
{
Name = "test{-VALUE-FORMS-}identity"
};
Parameter testParameterLC = new Parameter()
{
Name = "test{-VALUE-FORMS-}lc"
};
parameters.AddParameter(nameParameter);
parameters.AddParameter(testParameterIdentity);
parameters.AddParameter(testParameterLC);
parameters.ResolvedValues[nameParameter] = "testName";
parameters.ResolvedValues[testParameterIdentity] = "testproject";
parameters.ResolvedValues[testParameterLC] = "testproject";
//prepare renames configuration
List <IReplacementTokens> symbolBasedRenames = new List <IReplacementTokens>();
symbolBasedRenames.Add(new ReplacementTokens("test{-VALUE-FORMS-}identity", TokenConfig.FromValue("replace")));
symbolBasedRenames.Add(new ReplacementTokens("test{-VALUE-FORMS-}lc", TokenConfig.FromValue("replace")));
IReadOnlyDictionary <string, string> allChanges = setup.GetRenames("./", targetDir, parameters, symbolBasedRenames);
Assert.Equal(2, allChanges.Count);
Assert.Equal("testproject1_file.txt", allChanges["replace1_file.txt"]);
Assert.Equal("testproject2_file.txt", allChanges["replace2_file.txt"]);
}
public void CanReadFilenameReplacementConfigWithForms()
{
string configContent = @"
{
""identity"": ""test"",
""symbols"": {
""testparam"": {
""type"": ""parameter"",
""datatype"": ""string"",
""fileRename"": ""TestParamFileReplacement"",
""forms"": {
""global"" : [ ""identity"", ""lc"", ""uc""]
}
},
""testgenerated"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""fileRename"": ""testgeneratedfilereplacement""
},
""testgenerated2"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""replace"": ""testgeneratedreplacement""
},
},
""forms"": {
""lc"": {
""identifier"": ""lowercase""
},
""uc"": {
""identifier"": ""uppercase""
}
}
}";
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(JObject.Parse(configContent));
IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment();
RunnableProjectConfig runnableConfig =
new RunnableProjectConfig(environment, A.Fake <IGenerator>(), configModel);
Assert.Equal(4, runnableConfig.SymbolFilenameReplacements.Count);
Assert.Equal(3, runnableConfig.SymbolFilenameReplacements.Count(x => x.VariableName.Contains("testparam")));
Assert.Equal("TestParamFileReplacement", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName == "testparam{-VALUE-FORMS-}identity").OriginalValue.Value);
Assert.Equal("TESTPARAMFILEREPLACEMENT", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName == "testparam{-VALUE-FORMS-}uc").OriginalValue.Value);
Assert.Equal("testparamfilereplacement", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName == "testparam{-VALUE-FORMS-}lc").OriginalValue.Value);
Assert.Equal("testgeneratedfilereplacement", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName == "testgenerated").OriginalValue.Value);
}
public void ExplicitNameSymbolWithCustomBindingRetainsCustomBinding()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ConfigWithNameSymbolWithCustomBinding);
Assert.True(configModel.Symbols.ContainsKey("name"));
ISymbolModel symbolInfo = configModel.Symbols["name"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol nameSymbol = symbolInfo as ParameterSymbol;
Assert.Equal("customBinding", symbolInfo.Binding);
}
// Note: this does not deal with configs split into multiple files.
public static IRunnableProjectConfig ConfigFromSource(IEngineEnvironmentSettings environment, IMountPoint mountPoint, string configFile = null)
{
if (string.IsNullOrEmpty(configFile))
{
configFile = DefaultConfigRelativePath;
}
string fullPath = Path.Combine(mountPoint.Info.Place, configFile);
string configContent = environment.Host.FileSystem.ReadAllText(fullPath);
JObject configJson = JObject.Parse(configContent);
return(SimpleConfigModel.FromJObject(environment, configJson));
}
public void ExplicitNameSymbolWithoutBindingGetsDefaultNameBinding()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(ConfigWithNameSymbolWithoutBinding);
Assert.True(configModel.Symbols.ContainsKey("name"));
ISymbolModel symbolInfo = configModel.Symbols["name"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol nameSymbol = symbolInfo as ParameterSymbol;
Assert.Equal("name", symbolInfo.Binding);
}
public void CanReadConstraintDefinition()
{
var json = new
{
identity = "test",
constraints = new
{
one = new
{
type = "con1",
args = "arg"
},
two = new
{
type = "con2",
args = new[]
{
"one", "two", "three"
}
},
three = new
{
type = "con3",
args = new
{
one = "one",
two = "two",
}
},
four = new
{
type = "con4"
},
}
};
var model = SimpleConfigModel.FromJObject(JObject.FromObject(json));
Assert.Equal(4, model.Constraints.Count);
Assert.Equal("con1", model.Constraints[0].Type);
Assert.Equal("con2", model.Constraints[1].Type);
Assert.Equal("con3", model.Constraints[2].Type);
Assert.Equal("con4", model.Constraints[3].Type);
Assert.Equal("\"arg\"", model.Constraints[0].Args);
Assert.Equal("[\"one\",\"two\",\"three\"]", model.Constraints[1].Args);
Assert.Equal("{\"one\":\"one\",\"two\":\"two\"}", model.Constraints[2].Args);
Assert.Null(model.Constraints[3].Args);
}
// Note: this does not deal with configs split into multiple files.
internal static IRunnableProjectConfig ConfigFromSource(IEngineEnvironmentSettings environment, IMountPoint mountPoint, string configFile = null)
{
if (string.IsNullOrEmpty(configFile))
{
configFile = DefaultConfigRelativePath;
}
using Stream stream = mountPoint.FileInfo(configFile).OpenRead();
using StreamReader streamReader = new StreamReader(stream);
string configContent = streamReader.ReadToEnd();
JObject configJson = JObject.Parse(configContent);
return(SimpleConfigModel.FromJObject(environment, configJson));
}
public void ParameterSymbolWithNoValueFormsGetsIdentityFormAdded()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ConfigForSymbolWithoutValueForms);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = paramSymbol.Forms.GlobalForms.ToList();
Assert.Equal(1, configuredValueFormNames.Count);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[0]);
}
public async Task CanProcessDifferentHostNames(string hostName, string fallbackHostNames, string hostVersion, bool expectedResult)
{
var config = new
{
identity = "test",
constraints = new
{
host = new
{
type = "host",
args = new[]
{
new
{
hostName = "host1",
version = "[1.0, 2.0]"
},
new
{
hostName = "fallback",
version = "[2.0, 3.0]"
},
}
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Host.HostIdentifier).Returns(hostName);
A.CallTo(() => settings.Host.Version).Returns(hostVersion);
A.CallTo(() => settings.Host.FallbackHostTemplateConfigNames).Returns(fallbackHostNames.Split('|'));
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new HostConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
if (expectedResult)
{
Assert.Equal(TemplateConstraintResult.Status.Allowed, evaluateResult.EvaluationStatus);
}
else
{
Assert.Equal(TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
}
}
public void ParameterSymbolWithoutIdentityValueFormGetsIdentityAddedAsFirst()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ArrayConfigForSymbolWithFormsButNotIdentity);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
Assert.Single(paramSymbol.Forms.GlobalForms.ToList()
.Where(x => string.Equals(x, IdentityValueForm.FormName, StringComparison.OrdinalIgnoreCase))
);
Assert.Equal(0, paramSymbol.Forms.GlobalForms.ToList().IndexOf(IdentityValueForm.FormName));
}
public async Task CanReadConfiguration_ExactVersion()
{
var config = new
{
identity = "test",
constraints = new
{
host = new
{
type = "host",
args = new[]
{
new
{
hostName = "host1",
version = ""
},
new
{
hostName = "host2",
version = "1.0.0"
},
new
{
hostName = "host3",
version = "[1.0.0-*]"
},
}
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Host.HostIdentifier).Returns("host2");
A.CallTo(() => settings.Host.Version).Returns("2.0.0");
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new HostConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
Assert.Equal("Running template on host2 (version: 2.0.0) is not supported, supported hosts is/are: host1, host2(1.0.0), host3([1.0.0-*]).", evaluateResult.LocalizedErrorMessage);
Assert.Null(evaluateResult.CallToAction);
}
public async Task Evaluate_MultipleConflictingProviders()
{
var config = new
{
identity = "test-constraint-01",
constraints = new
{
specVersions = new
{
type = "workload",
args = new[] { "workloadA", "workloadB" }
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IWorkloadsInfoProvider workloadInfoProviderA = A.Fake <IWorkloadsInfoProvider>();
A.CallTo(() => workloadInfoProviderA
.GetInstalledWorkloadsAsync(A <CancellationToken> ._))
.Returns(Task.FromResult(new[] { "workload", "workloadA" }.Select(s => new WorkloadInfo(s, $"D:{s}"))));
IWorkloadsInfoProvider workloadInfoProviderB = A.Fake <IWorkloadsInfoProvider>();
A.CallTo(() => workloadInfoProviderB
.GetInstalledWorkloadsAsync(A <CancellationToken> ._))
.Returns(Task.FromResult(new[] { "workload", "workloadA", "workloadB" }.Select(s => new WorkloadInfo(s, $"D:{s}"))));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Components.OfType <IWorkloadsInfoProvider>()).Returns(new[] { workloadInfoProviderA, workloadInfoProviderB });
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new WorkloadConstraintFactory() });
List <(LogLevel, string)> messagesCollection = new();
ILogger logger = new InMemoryLoggerProvider(messagesCollection).CreateLogger("x");
A.CallTo(() => settings.Host.Logger).Returns(logger);
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(TemplateConstraintResult.Status.NotEvaluated, evaluateResult.EvaluationStatus);
Assert.Equal(0, messagesCollection.Count(t => t.Item1 >= LogLevel.Warning));
Assert.StartsWith("The constraint 'workload' failed to initialize", evaluateResult.LocalizedErrorMessage);
}
public async Task CanReadConfiguration_VersionRange()
{
var config = new
{
identity = "test",
constraints = new
{
host = new
{
type = "host",
args = new[]
{
new
{
hostName = "host1",
version = ""
},
new
{
hostName = "host2",
version = "1.0.0"
},
new
{
hostName = "host3",
version = "[1.0.0-*]"
},
}
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Host.HostIdentifier).Returns("host3");
A.CallTo(() => settings.Host.Version).Returns("2.0.0");
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new HostConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
Assert.Equal(TemplateConstraintResult.Status.Allowed, evaluateResult.EvaluationStatus);
}
public void ObjectValueFormDefinitionRespectsAddIdentityFalse()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ConfigWithObjectValueFormDefinitionAddIdentityFalse);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = paramSymbol.Forms.GlobalForms.ToList();
Assert.Equal(3, configuredValueFormNames.Count);
Assert.Equal("foo", configuredValueFormNames[0]);
Assert.Equal("bar", configuredValueFormNames[1]);
Assert.Equal("baz", configuredValueFormNames[2]);
}
public void NameSymbolObjectValueFormWithIdentityWithoutAddIdentityRetainsConfiguredForms()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(NameConfigObjectValueFormWithIdentityAndAddIdentityUnspecified);
Assert.True(configModel.Symbols.ContainsKey("name"));
ISymbolModel symbolInfo = configModel.Symbols["name"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = paramSymbol.Forms.GlobalForms.ToList();
Assert.Equal(4, configuredValueFormNames.Count);
Assert.Equal("foo", configuredValueFormNames[0]);
Assert.Equal("bar", configuredValueFormNames[1]);
Assert.Equal("baz", configuredValueFormNames[2]);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[3]);
}
public void ArrayConfigNameSymbolWithoutIdentityFormGetsIdentityFormAddedAsFirst()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ArrayConfigWithNameSymbolAndValueFormsButNotIdentity);
Assert.True(configModel.Symbols.ContainsKey("name"));
ISymbolModel symbolInfo = configModel.Symbols["name"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol nameSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = nameSymbol.Forms.GlobalForms.ToList();
Assert.Equal(4, configuredValueFormNames.Count);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[0]);
Assert.Equal("foo", configuredValueFormNames[1]);
Assert.Equal("bar", configuredValueFormNames[2]);
Assert.Equal("baz", configuredValueFormNames[3]);
}
public void ParameterSymbolWithArrayIdentityValueFormRetainsFormsUnmodified()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ArrayConfigForSymbolWithValueFormsIncludingIdentity);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = paramSymbol.Forms.GlobalForms.ToList();
Assert.Equal(4, configuredValueFormNames.Count);
Assert.Equal("foo", configuredValueFormNames[0]);
Assert.Equal("bar", configuredValueFormNames[1]);
Assert.Equal("baz", configuredValueFormNames[2]);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[3]);
}
public void ParameterSymbolObjectValueFormDefinitionInfersAddIdentityTrue()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ParameterConfigObjectValueFormWithoutIdentityAndAddIdentityUnspecified);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol paramSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = paramSymbol.Forms.GlobalForms.ToList();
Assert.Equal(4, configuredValueFormNames.Count);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[0]);
Assert.Equal("foo", configuredValueFormNames[1]);
Assert.Equal("bar", configuredValueFormNames[2]);
Assert.Equal("baz", configuredValueFormNames[3]);
}
public void ObjectConfigParameterSymbolWithIdentityFormAndAddIdentityTrueRetainsConfiguredFormsExactly()
{
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(_engineEnvironmentSettings, ObjectConfigParameterSymbolWithIdentityFormAndAddIdentityTrue);
Assert.True(configModel.Symbols.ContainsKey("testSymbol"));
ISymbolModel symbolInfo = configModel.Symbols["testSymbol"];
Assert.True(symbolInfo is ParameterSymbol);
ParameterSymbol nameSymbol = symbolInfo as ParameterSymbol;
IList <string> configuredValueFormNames = nameSymbol.Forms.GlobalForms.ToList();
Assert.Equal(4, configuredValueFormNames.Count);
Assert.Equal("foo", configuredValueFormNames[0]);
Assert.Equal("bar", configuredValueFormNames[1]);
Assert.Equal(IdentityValueForm.FormName, configuredValueFormNames[2]);
Assert.Equal("baz", configuredValueFormNames[3]);
}