public void TestCreatingSettingsFromDictionary()
{
var dict = new Dictionary <string, object>()
{
{
"nuix",
new Dictionary <string, object>()
{
{ "UseDongle", true }, { "Features", new List <string>()
{
"a", "b", "c"
} }
}
}
};
var entity = Entity.Create(("Connectors", dict));
var settings = new SCLSettings(entity);
TestOutputHelper.WriteLine(settings.ToString());
var useDongleString = settings.Entity.TryGetNestedString("Connectors", "Nuix", "UseDongle");
useDongleString.HasValue.Should().BeTrue();
useDongleString.Value.Should().Be(true.ToString());
var useDongleBool = settings.Entity.TryGetNestedBool("Connectors", "Nuix", "UseDongle");
useDongleBool.Should().BeTrue();
}
TryGetInjectedContexts(SCLSettings settings)
{
var colorName =
settings.Entity.TryGetNestedString(
"connectors",
"example",
ColorSource.KeyName
);
if (colorName.HasNoValue)
{
return(ErrorCode.MissingStepSettingsValue.ToErrorBuilder(
"example",
ColorSource.KeyName
));
}
var color = Color.FromName(colorName.Value);
var list = new List <(string Name, object Context)>()
{
{ (ColorSource.KeyName, new ColorSource(color)) }
};
return(list);
}
public static IEnumerable <(string Key, ConnectorSettings Settings)> CreateFromSCLSettings(
SCLSettings sclSettings)
{
var connectorsEntity = sclSettings.Entity.TryGetNestedEntity(SCLSettings.ConnectorsKey);
if (connectorsEntity.HasNoValue)
{
yield break;
}
foreach (var property in connectorsEntity.Value)
{
if (property.BestValue is EntityValue.NestedEntity nestedEntity)
{
var connectorSettings =
EntityConversionHelpers.TryCreateFromEntity <ConnectorSettings>(
nestedEntity.Value
);
if (connectorSettings.IsSuccess)
{
yield return(new(property.Name, connectorSettings.Value));
}
}
}
}
/// <summary>
/// Creates a new SCL Runner
/// </summary>
public SCLRunner(
SCLSettings settings,
ILogger logger,
StepFactoryStore stepFactoryStore,
IExternalContext externalContext)
{
_settings = settings;
_logger = logger;
_stepFactoryStore = stepFactoryStore;
_externalContext = externalContext;
}
TryGetInjectedContexts(SCLSettings settings)
{
IFileSystem fileSystem = new FileSystem();
IReadOnlyCollection <(string Name, object Context)> list =
new List <(string Name, object Context)> {
(FileSystemKey, fileSystem)
};
return(Result.Success <IReadOnlyCollection <(string Name, object Context)>, IErrorBuilder>(
list
));
}
}
/// <inheritdoc />
public override Result <Unit, IError> VerifyThis(SCLSettings settings)
{
var r = SettingsHelpers.TryGetNuixSettings(
ConnectorSettings.CreateFromSCLSettings(settings).Select(x => x.Settings)
)
.Bind(NuixConnectionHelper.TryGetConsoleArguments)
.MapError(x => x.WithLocation(this));
if (r.IsFailure)
{
return(r.ConvertFailure <Unit>());
}
return(base.VerifyThis(settings));
}
public void TestGettingConnectorSettingsFromString()
{
var settings = SCLSettings.CreateFromString(ConnectorJson);
var connectorSettings = ConnectorSettings.CreateFromSCLSettings(settings).ToList();
connectorSettings.Should().HaveCount(1);
var nuixSettings = connectorSettings.Single().Settings;
nuixSettings.Id.Should().Be("Reductech.EDR.Nuix");
nuixSettings.Version.Should().Be("0.9.0");
nuixSettings.Enable.Should().Be(true);
nuixSettings.Settings.TryGetNestedBool("UseDongle").Should().BeTrue();
}
private static IHostBuilder CreateHostBuilder() => new HostBuilder()
.ConfigureAppConfiguration(
(_, config) =>
{
config.AddJsonFile("appsettings.json", false, false);
config.AddEnvironmentVariables(prefix: "EDR_");
}
)
.ConfigureServices(
(context, services) =>
{
var fs = new FileSystem();
services.AddSingleton <IFileSystem>(fs);
services.AddConnectorManager(context.Configuration);
services.AddSingleton <ConnectorCommand>();
services.AddSingleton <RunCommand>();
services.AddSingleton <StepsCommand>();
services.AddSingleton <ValidateCommand>();
services.AddSingleton <EDRMethods>();
var sclSettings = SCLSettings.CreateFromIConfiguration(context.Configuration);
services.AddSingleton(sclSettings);
}
)
.ConfigureLogging(
(context, logging) =>
{
logging.ClearProviders();
logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
var nlogConfig =
new NLogLoggingConfiguration(context.Configuration.GetSection("nlog"));
LogManager.Configuration = nlogConfig;
logging.AddNLog(nlogConfig);
}
);
/// <summary>
/// Creates a StepFactoryStore with steps from the given assemblies
/// </summary>
public static StepFactoryStore Create(SCLSettings settings, params Assembly[] assemblies)
{
var settingsDict = ConnectorSettings.CreateFromSCLSettings(settings)
.Select(x => x.Settings)
.ToDictionary(x => x.Id);
var data = new List <ConnectorData>();
foreach (var assembly in assemblies)
{
var connectorSettings = ConnectorSettings.DefaultForAssembly(assembly);
if (settingsDict.TryGetValue(assembly.GetName().Name !, out var cs))
{
connectorSettings = cs;
}
data.Add(new ConnectorData(connectorSettings, assembly));
}
return(Create(data.ToArray()));
}
public void TestCreateFromIConfiguration()
{
var myConfiguration = new Dictionary <string, string>
{
{ "Key1", "Value1" },
{ "Nested:Key1", "NestedValue1" },
{ "Nested:Key2:0", "alpha" },
{ "Nested:Key2:1", "beta" },
{ "Nested:Key2:2", "gamma" },
};
IConfiguration configuration = new ConfigurationBuilder()
.AddInMemoryCollection(myConfiguration)
.Build();
var settings = SCLSettings.CreateFromIConfiguration(configuration);
var key1 = settings.Entity.TryGetValue("Key1");
key1.ShouldHaveValue();
key1.Value.GetPrimitiveString().Should().Be("Value1");
var nestedKey1 = settings.Entity.TryGetValue(new EntityPropertyKey("Nested.Key1"));
nestedKey1.ShouldHaveValue();
nestedKey1.Value.GetPrimitiveString().Should().Be("NestedValue1");
var nestedKey2 = settings.Entity.TryGetValue(new EntityPropertyKey("Nested.Key2"));
nestedKey2.ShouldHaveValue();
nestedKey2.Value.Should().BeOfType <EntityValue.NestedList>("Value should be a list");
(nestedKey2.Value as EntityValue.NestedList) !.Value.Select(x => x.GetPrimitiveString())
.Should()
.BeEquivalentTo(new object[] { "alpha", "beta", "gamma" });
}
/// <summary>
/// Check that the requirement is met by these settings.
/// </summary>
public Result <Unit, IErrorBuilder> Check(SCLSettings settings)
{
if (settings.Entity.Dictionary.TryGetValue(SCLSettings.ConnectorsKey, out var connectors) &&
connectors.BestValue is EntityValue.NestedEntity connectorsEntity)
{
var connector = connectorsEntity.Value.TryGetValue(Name);
if (connector.HasValue && connector.Value is EntityValue.NestedEntity connectorEntity)
{
var connectorVersion = connectorEntity.Value.TryGetValue(SCLSettings.VersionKey);
if (connectorVersion.HasValue)
{
if (Version.TryParse(
connectorVersion.Value.GetPrimitiveString(),
out var version
))
{
if (MaxVersion != null && MaxVersion < version)
{
return(ErrorCode.RequirementNotMet.ToErrorBuilder(this));
}
if (MinVersion != null && MinVersion > version)
{
return(ErrorCode.RequirementNotMet.ToErrorBuilder(this));
}
if (Features != null && Features.Any())
{
var connectorFeatures =
connectorEntity.Value.TryGetValue(SCLSettings.FeaturesKey);
if (connectorFeatures.HasValue &&
connectorFeatures.Value is EntityValue.NestedList featuresList)
{
var missingFeatures = Features.Except(
featuresList.Value.Select(x => x.GetPrimitiveString()),
StringComparer.OrdinalIgnoreCase
);
if (missingFeatures.Any())
{
return(ErrorCode.RequirementNotMet.ToErrorBuilder(this));
}
}
else
{
return(ErrorCode.MissingStepSettingsValue.ToErrorBuilder(
Name,
SCLSettings.FeaturesKey
));
}
}
return(Unit.Default);
}
return(ErrorCode.CouldNotParse.ToErrorBuilder(
connectorVersion.Value.ToString() !,
"Version"
));
}
return(ErrorCode.MissingStepSettingsValue.ToErrorBuilder(
Name,
SCLSettings.VersionKey
));
}
}
else
{
}
return(ErrorCode.MissingStepSettings.ToErrorBuilder(Name));
}
public void TestCreatingSettingsFromString()
{
var settings = SCLSettings.CreateFromString(ConnectorJson);
TestOutputHelper.WriteLine(settings.ToString());
settings.Entity.TryGetNestedEntity("Connectors")
.Value
.TryGetNestedEntity("Nuix")
.Value
.TryGetNestedEntity("Settings")
.Value
.TryGetValue("UseDongle")
.Value.GetPrimitiveString()
.Should()
.Be(true.ToString());
var udString = settings.Entity.TryGetNestedString(
"Connectors",
"Nuix",
"Settings",
"UseDongle"
);
udString.HasValue.Should().BeTrue();
udString.Value.Should().Be(true.ToString());
var udBool = settings.Entity.TryGetNestedBool(
"Connectors",
"Nuix",
"Settings",
"UseDongle"
);
udBool.Should().BeTrue();
var featuresList = settings.Entity.TryGetNestedList(
"Connectors",
"Nuix",
"Settings",
"Features"
);
featuresList.HasValue.Should().BeTrue();
featuresList.Value.Should()
.BeEquivalentTo(
"ANALYSIS",
"CASE_CREATION",
"EXPORT_ITEMS",
"METADATA_IMPORT",
"OCR_PROCESSING",
"PRODUCTION_SET"
);
var consoleArgsList = settings.Entity.TryGetNestedList(
"Connectors",
"Nuix",
"Settings",
"ConsoleArguments"
);
consoleArgsList.HasValue.Should().BeTrue();
consoleArgsList.Value.Should()
.BeEquivalentTo(
"-Dnuix.licence.handlers=server",
"-Dnuix.registry.servers=licenseSource"
);
var username = settings.Entity.TryGetNestedString(
"Connectors",
"Nuix",
"Settings",
"EnvironmentVariables",
"NUIX_USERNAME"
);
username.HasValue.Should().BeTrue();
username.Value.Should().BeEquivalentTo("myName");
}
public static T WithSettings <T>(this T cws, SCLSettings settings) where T : ICaseThatExecutes
{
cws.Settings = settings;
return(cws);
}
/// <summary>
/// Returns a new SCLSettings object with a property added
/// </summary>
public static SCLSettings WithProperty(
this SCLSettings settings,
object?value,
params string[] pathComponents)
{
var e = Entity.Create(new[] { (new EntityPropertyKey(pathComponents), value) });
private record TestCase(
string Name,
RequirementTestStep Step,
SCLSettings Settings,
bool ExpectSuccess) : ITestInstance
