/// <inheritdoc />
public async Task RunAsync(ITestOutputHelper testOutputHelper)
{
var spf = StepFactoryStore.Create();
var loggerFactory = TestLoggerFactory.Create();
loggerFactory.AddXunit(testOutputHelper);
var logger = loggerFactory.CreateLogger("Test");
var repo = new MockRepository(MockBehavior.Strict);
var context = ExternalContextSetupHelper.GetExternalContext(repo);
var sclRunner = new SCLRunner(
SCLSettings.EmptySettings,
logger,
spf,
context
);
var r = await sclRunner.RunSequenceFromTextAsync(
SCL,
new Dictionary <string, object>(),
CancellationToken.None
);
r.ShouldBeSuccessful();
loggerFactory.Sink.LogEntries.Should().SatisfyRespectively(ExpectedLogs);
}
public async Task RunSCLFromFile(string path)
{
var scl = await File.ReadAllTextAsync(path);
TestOutputHelper.WriteLine(scl);
var sfs = StepFactoryStore.Create();
var stepResult = SCLParsing.TryParseStep(scl)
.Bind(x => x.TryFreeze(TypeReference.Any.Instance, sfs));
if (stepResult.IsFailure)
{
throw new XunitException(
string.Join(
", ",
stepResult.Error.GetAllErrors()
.Select(x => x.Message + " " + x.Location.AsString())
)
);
}
var monad = new StateMonad(
TestOutputHelper.BuildLogger(),
SCLSettings.EmptySettings,
sfs,
ExternalContext.Default,
new Dictionary <string, object>()
);
var r = await stepResult.Value.Run <Unit>(monad, CancellationToken.None);
r.ShouldBeSuccessful();
}
/// <inheritdoc />
public async Task RunAsync(ITestOutputHelper testOutputHelper)
{
testOutputHelper.WriteLine(SCL);
var stepFactoryStore = StepFactoryStore.Create();
var loggerFactory = TestLoggerFactory.Create();
loggerFactory.AddXunit(testOutputHelper);
var repository = new MockRepository(MockBehavior.Strict);
var externalContext = ExternalContextSetupHelper.GetExternalContext(repository);
var runner = new SCLRunner(
SCLSettings.EmptySettings,
loggerFactory.CreateLogger("Test"),
stepFactoryStore,
externalContext
);
var result = await runner.RunSequenceFromTextAsync(
SCL,
new Dictionary <string, object>(),
CancellationToken.None
);
result.ShouldBeSuccessful();
LogChecker.CheckLoggedValues(
loggerFactory,
LogLevel.Information,
ExpectedLoggedValues
);
}
public virtual async Task <StateMonad> GetStateMonad(
MockRepository mockRepository,
ILogger logger)
{
var externalContext = ExternalContextSetupHelper.GetExternalContext(mockRepository);
var tStepAssembly = Assembly.GetAssembly(typeof(TStep)) !;
var sfs = StepFactoryStoreToUse.Unwrap(
StepFactoryStore.Create(Settings, tStepAssembly)
);
var stateMonad = new StateMonad(
logger,
Settings,
sfs,
externalContext,
new Dictionary <string, object>()
);
foreach (var action in InitialStateActions)
{
await action(stateMonad);
}
return(stateMonad);
}
private IStateMonad CreateMonad(MockRepository repo)
{
return
(new StateMonad(
repo.OneOf <ILogger>(),
new SCLSettings(Entity.Create()),
StepFactoryStore.Create(Array.Empty <ConnectorData>()),
repo.OneOf <IExternalContext>(),
repo.OneOf <IReadOnlyDictionary <string, object> >()
));
}
/// <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;
}
public static StateMonad CreateStateMonad(ILogger logger)
{
var repo = new MockRepository(MockBehavior.Strict);
var stateMonad = new StateMonad(
logger,
SCLSettings.EmptySettings,
StepFactoryStore.Create(),
repo.OneOf <IExternalContext>(),
new Dictionary <string, object>()
);
return(stateMonad);
}
public async Task RunSCLSequence()
{
const string scl = @"
- <root> = 'Documentation'
- <docs> = GenerateDocumentation
# Create a directory for each connector
- <docs>
| ArrayDistinct (From <Entity> 'Directory')
| ForEach (
CreateDirectory (PathCombine [<root>, (From <Entity> 'Directory')])
)
# Export all steps to .\<root>\ConnectorName\StepName.md
- <docs>
| Foreach (
FileWrite
(From <Entity> 'FileText')
(PathCombine [<root>, (From <Entity> 'Directory'), (From <Entity> 'FileName')])
)
";
var logger =
TestOutputHelper.BuildLogger(new LoggingConfig()
{
LogLevel = LogLevel.Information
});
var sfs = StepFactoryStore.Create();
var runner = new SCLRunner(
SCLSettings.EmptySettings,
logger,
sfs,
ExternalContext.Default
);
var r = await runner.RunSequenceFromTextAsync(
scl,
new Dictionary <string, object>(),
CancellationToken.None
);
r.ShouldBeSuccessful();
}
public static IStateMonad GetStateMonad(
ITestLoggerFactory testLoggerFactory,
IExternalProcessRunner externalProcessRunner,
IConsole console)
{
var sclSettings = SettingsHelpers.CreateSCLSettings(
new NuixSettings(
Constants.NuixConsoleExe,
new Version(8, 0),
true,
Constants.AllNuixFeatures
)
);
var sfs = StepFactoryStore.Create(
sclSettings,
Assembly.GetAssembly(typeof(IRubyScriptStep)) !
);
var fileSystem = new MockFileSystem(
new Dictionary <string, MockFileData>()
{
{ NuixConnectionHelper.NuixGeneralScriptName, "Ultimate Nuix Script" }
},
AppContext.BaseDirectory
);
var monad = new StateMonad(
testLoggerFactory.CreateLogger("Test"),
sclSettings,
sfs,
new ExternalContext(
externalProcessRunner,
console,
(ConnectorInjection.FileSystemKey, fileSystem)
),
new Dictionary <string, object>()
);
return(monad);
}
/// <inheritdoc />
public override async Task <IStep> GetStepAsync(ITestOutputHelper testOutputHelper)
{
await Task.CompletedTask;
var tStepAssembly = Assembly.GetAssembly(typeof(TStep)) !;
var sfs = StepFactoryStoreToUse.Unwrap(
StepFactoryStore.Create(Settings, tStepAssembly)
);
testOutputHelper.WriteLine(SCL);
var deserializeResult = SCLParsing.TryParseStep(SCL);
deserializeResult.ShouldBeSuccessful();
var freezeResult = deserializeResult.Value.TryFreeze(TypeReference.Any.Instance, sfs);
freezeResult.ShouldBeSuccessful();
return(freezeResult.Value);
}
/// <inheritdoc />
public override async Task <IStep> GetStepAsync(ITestOutputHelper testOutputHelper)
{
await Task.CompletedTask;
var yaml = Steps.Serialize();
testOutputHelper.WriteLine(yaml);
var sfs = StepFactoryStore.Create(
Settings,
Assembly.GetAssembly(typeof(TStep)) !,
Assembly.GetAssembly(typeof(DeleteItem)) !
);
var deserializedStep = SCLParsing.TryParseStep(yaml);
deserializedStep.ShouldBeSuccessful();
var unfrozenStep = deserializedStep.Value.TryFreeze(TypeReference.Any.Instance, sfs);
unfrozenStep.ShouldBeSuccessful();
return(unfrozenStep.Value);
}
public static T WithStepFactoryStore <T>(this T cws, StepFactoryStore stepFactoryStore)
where T : ICaseThatExecutes
{
cws.StepFactoryStoreToUse = stepFactoryStore;
return(cws);
}
public async Task TestConnector()
{
var logger = new TestOutputLogger("Step Logger", TestOutputHelper);
var absolutePath = PluginLoadContext.GetAbsolutePath(RelativePath);
var assembly = PluginLoadContext.LoadPlugin(
absolutePath,
logger
);
assembly.ShouldBeSuccessful();
var stepTypes = assembly.Value.GetTypes()
.Where(x => typeof(IStep).IsAssignableFrom(x))
.ToList();
foreach (var type in stepTypes)
{
TestOutputHelper.WriteLine(type.Name);
}
var stepFactoryStore = StepFactoryStore.Create(
new ConnectorData(ConnectorSettings.DefaultForAssembly(assembly.Value), assembly.Value)
);
var injectedContextsResult = stepFactoryStore.TryGetInjectedContexts(
new SCLSettings(
Entity.Create(
new List <(EntityPropertyKey key, object?value)>()
{
(new EntityPropertyKey(new[] { "connectors", "example", "colorSource" }),
"Red")
}
)
)
);
injectedContextsResult.ShouldBeSuccessful();
var externalContext = ExternalContext.Default with
{
InjectedContexts = injectedContextsResult.Value
};
var runner = new SCLRunner(
SCLSettings.EmptySettings,
logger,
stepFactoryStore,
externalContext
);
var r = await
runner.RunSequenceFromTextAsync(
"Log (GetTestString)",
new Dictionary <string, object>(),
CancellationToken.None
);
r.ShouldBeSuccessful();
}
}
