public async void RunScript_ReadsDataFromInputStream()
{
var lf = TestLoggerFactory.Create();
var script = @"$Input | ForEach { Write-Output $_ }";
var expected = new[] { 32, 120, 71, 89, 20 };
var input = new PSDataCollection <PSObject>(5);
_ = Task.Run(
() =>
{
foreach (var num in expected)
{
input.Add(num);
Thread.Sleep(num);
}
input.Complete();
}
);
var result = await PwshRunner.RunScript(script, lf.CreateLogger("Test"), null, input);
var actual = result.Select(o => (int)o.BaseObject).ToArray();
Assert.Equal(expected, actual);
}
/// <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 void LogError_WhenErrorHasExceptionAndLocation_LogsMessage()
{
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger("Test");
const string stepName = "TestStep";
var location = new ErrorLocation(
stepName,
new TextLocation("Text", new TextPosition(1, 1, 1), new TextPosition(2, 2, 2))
);
var expected = $"Test (Step: {stepName} {location.TextLocation})";
var error = new SingleError(location, new Exception("Test"), ErrorCode.UnexpectedEnumValue);
logger.LogError(error);
var logMessages = loggerFactory.Sink.LogEntries.ToList();
Assert.NotNull(logMessages[0].Exception);
//Test (Step: TestStep Line: 1, Col: 1, Idx: 1 - Line: 2, Col: 2, Idx: 2 Text: Text)
Assert.Contains(
logMessages,
l => l.LogLevel == LogLevel.Error && l.Message !.Equals(expected)
);
}
public void LogError_WhenErrorHasNoExceptionAndLocation_LogsMessage()
{
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger("Test");
var errorCode = ErrorCode.ExternalProcessError;
const string stepName = "TestStep";
var location = new ErrorLocation(
stepName,
new TextLocation("Text", new TextPosition(1, 1, 1), new TextPosition(2, 2, 2))
);
var expected =
$"{errorCode.GetFormattedMessage("error")} (Step: {stepName} {location.TextLocation})";
var error = new SingleError(location, errorCode, "error");
logger.LogError(error);
var logMessages = loggerFactory.Sink.LogEntries.ToList();
Assert.Null(logMessages[0].Exception);
Assert.Contains(
logMessages,
l => l.LogLevel == LogLevel.Error && l.Message !.Equals(expected)
);
}
public void MessagesLoggedInScopes_ShouldHaveCorrectScopes()
{
//Arrange
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger("Test");
//Act
using (logger.BeginScope("Outer Scope"))
{
logger.LogInformation("Message 1");
using (logger.BeginScope("Inner Scope"))
{
logger.LogInformation("Message 2");
}
logger.LogInformation("Message 3");
}
//Assert
var expectations = new List <(string expectedMessage, string[] expectedScopes)>()
{
("Message 1", new [] { "Outer Scope" }),
("Message 2", new [] { "Outer Scope", "Inner Scope" }),
("Message 3", new [] { "Outer Scope" })
};
Assert.Equal(expectations.Count, loggerFactory.Sink.LogEntries.Count());
foreach (var(logEntry, (expectedMessage, expectedScope)) in loggerFactory.Sink.LogEntries.Zip(expectations))
{
Assert.Equal(logEntry.Message, expectedMessage);
Assert.Equal(expectedScope, logEntry.Scopes.Select(x => x.Message));
Assert.Equal(expectedMessage, logEntry.Message);
}
}
public void RunSCL_WhenRunnerIsFailure_LogsErrorAndReturnsFailure()
{
var factory = TestLoggerFactory.Create(x => x.SetMinimumLevel(LogLevel.Debug));
var fs = new MockFileSystem();
var connMan = new FakeConnectorManager();
var run = new Mock <RunCommand>(factory.CreateLogger <RunCommand>(), fs, connMan);
run.Setup(r => r.GetInjectedContexts(It.IsAny <StepFactoryStore>(), It.IsAny <SCLSettings>()))
.Returns(() => new ErrorBuilder(ErrorCode.Unknown, "Just Testing"));
var sp = new ServiceCollection()
.AddSingleton(new ConnectorCommand(connMan))
.AddSingleton(run.Object)
.AddSingleton(new StepsCommand(connMan))
.AddSingleton(new ValidateCommand(factory.CreateLogger <ValidateCommand>(), fs, connMan))
.AddSingleton <EDRMethods>()
.BuildServiceProvider();
var result = new AppRunner <EDRMethods>()
.UseMicrosoftDependencyInjection(sp)
.UseDefaultMiddleware()
.RunInMem($"run scl \"Log '{TheUltimateTestString}'\"");
result.ExitCode.Should().Be(1);
Assert.Contains(
factory.Sink.LogEntries,
l => l.LogLevel == LogLevel.Error &&
l.Message !.Contains("Unknown Error: 'Just Testing'")
);
}
public void RunPath_WhenSCLFunctionIsSuccess_ReturnsSuccess()
{
const string path = @"c:\temp\file.scl";
var factory = TestLoggerFactory.Create(x => x.SetMinimumLevel(LogLevel.Debug));
var fs = new MockFileSystem();
fs.AddFile(path, $"- Log '{TheUltimateTestString}'");
var sp = GetDefaultServiceProvider(factory, fs, null);
var result = new AppRunner <EDRMethods>()
.UseMicrosoftDependencyInjection(sp)
.UseDefaultMiddleware()
.RunInMem($"run {path}");
result.ExitCode.Should().Be(0);
factory.Sink.LogEntries.Select(x => x.Message)
.Should()
.BeEquivalentTo(
"EDR Sequence Started",
TheUltimateTestString,
"EDR Sequence Completed"
);
}
GetActionResult(
ConnectionOutput output,
string[]?stdOut,
string[]?stdErr)
{
const string?casePath = @"d:\case";
const string?search = "*.png";
const string?tag = "image";
var action = ConnectionTestsHelper.SearchAndTagAction(casePath, search, tag, output);
action.WriteToStdOut = stdOut;
action.WriteToStdErr = stdErr;
var loggerFactory = TestLoggerFactory.Create();
var nuixConnection = ConnectionTestsHelper.GetNuixConnection(
loggerFactory,
ConnectionTestsHelper.SearchHelperAction,
ConnectionTestsHelper.ExpandHelperAction,
action
);
var result = await nuixConnection.RunFunctionAsync(
ConnectionTestsHelper.GetStateMonadForProcess(loggerFactory),
null,
new NuixSearchAndTag().RubyScriptStepFactory.RubyFunction,
ConnectionTestsHelper.SearchAndTagParams(casePath, search, tag),
CasePathParameter.IgnoresOpenCase.Instance,
new CancellationToken()
);
return(loggerFactory, result);
}
/// <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 async void RunScriptAsync_CorrectlyPassesVariablesToScript()
{
var lf = TestLoggerFactory.Create();
var script = @"1..6 | % { Write-Output (Get-Variable -Name ""Var$_"").Value }";
var entity = Entity.Create(
("Var1", "value1"),
("Var2", 2),
("Var3", 3.3),
("Var4", true),
("Var5", Core.SCLType.Enum),
("Var6", new DateTime(2020, 12, 12))
);
var result = await PwshRunner.RunScriptAsync(script, lf.CreateLogger("Test"), entity, null)
.ToListAsync();
for (var i = 0; i < entity.Dictionary.Count; i++)
{
Assert.Equal(
entity.Dictionary[$"Var{i + 1}"].BestValue.ObjectValue,
result[i].BaseObject
);
}
}
public WhenDispatchingMessage(ITestOutputHelper outputHelper)
{
_outputHelper = outputHelper;
_loggerFactory = TestLoggerFactory.Create(lb => lb.AddXUnit(outputHelper));
_messageMonitor = new TrackingLoggingMonitor(_loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_middlewareMap = new MiddlewareMap();
}
public async Task GetOrCreateNuixConnection_WhenScriptFileDoesNotExist_ReturnsError()
{
var fakeExternalProcess = new ExternalProcessMock(
1,
ConnectionTestsHelper.GetCreateCaseAction()
);
var fileMock =
Mock.Of <IFile>(f => f.Exists(It.IsAny <string>()) == false);
IStateMonad state = ConnectionTestsHelper.GetStateMonad(
TestLoggerFactory.Create(),
fakeExternalProcess,
ConsoleAdapter.Instance
);
//Remove the script from the file system
var nuixFileSystem =
state.ExternalContext.TryGetContext <IFileSystem>(ConnectorInjection.FileSystemKey);
nuixFileSystem.Value.File.Delete(NuixConnectionHelper.NuixGeneralScriptName);
var connection = await state.GetOrCreateNuixConnection(null, false);
Assert.True(connection.IsFailure);
Assert.Matches(
$"Could not find.+{NuixConnectionHelper.NuixGeneralScriptName}'",
connection.Error.AsString
);
}
public async void RunScript_ReadsDataFromOutputStream()
{
var logger = TestLoggerFactory.Create().CreateLogger("Test");
var script = @"Write-Output 'one'; Write-Output 2";
var result = await PwshRunner.RunScript(script, logger);
Assert.Equal(new List <PSObject> {
"one", 2
}, result);
}
public async Task GetOrCreateNuixConnection_WhenConnectionExists_ReturnsConnection()
{
var loggerFactory = TestLoggerFactory.Create();
var state = ConnectionTestsHelper.GetStateMonadWithConnection(loggerFactory);
var expected = state.GetVariable <NuixConnection>(NuixConnectionHelper.NuixVariableName);
var createConnection = await state.GetOrCreateNuixConnection(null, false);
Assert.True(createConnection.IsSuccess);
Assert.Same(expected.Value, createConnection.Value);
}
public void Logs_nothing_when_using_valid_custom_config()
{
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger <ResponseSerializationOptions>();
var options = new ResponseSerializationOptions(new ServiceCollection())
{
DefaultResponseCasing = ResponseCasing.PascalCase
};
options.ValidateConfiguration(logger);
Assert.Empty(loggerFactory.Sink.LogEntries.ToList());
}
public void Logs_nothing_when_using_valid_config_with_formatters()
{
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger <ResponseSerializationOptions>();
var options = new ResponseSerializationOptions(new ServiceCollection())
{
UseOutputFormatters = true
};
options.ValidateConfiguration(logger);
Assert.Empty(loggerFactory.Sink.LogEntries.ToList());
}
public void LogSituationNuix_LogsCorrectMessage()
{
var lf = TestLoggerFactory.Create();
var stateMonad = new StateMonad(
lf.CreateLogger("test"),
SettingsHelpers.CreateSCLSettings(NuixSettingsList.First()),
null !,
null !,
null !
);
var fields = typeof(LogSituationNuix).GetFields(BindingFlags.Static | BindingFlags.Public);
foreach (var field in fields)
{
var situation = field.GetValue(null) as LogSituationNuix;
if (situation == null)
{
continue;
}
var msg = LogMessages_EN.ResourceManager.GetString(situation.Code);
Assert.NotNull(msg);
// ReSharper disable once RemoveToList.1
var msgParams = Regex.Matches(msg !, "\\{(.+?)\\}")
.Select(m => m.Groups[1].Value)
.ToList()
.ToArray();
var counter = 0;
foreach (var p in msgParams)
{
msg = msg !.Replace(p, counter++.ToString());
}
var expected = string.Format(msg !, msgParams);
situation.Log(stateMonad, new And(), msgParams);
lf.Sink.LogEntries.Should()
.Contain(
x => x.LogLevel == situation.LogLevel &&
x.Message != null && x.Message.Equals(expected)
);
}
}
public async void RunScript_LogsErrorsWarningsAndInformation()
{
var lf = TestLoggerFactory.Create();
var script =
@"Write-Output 'one'; Write-Error 'error'; Write-Output 'two'; Write-Warning 'warning'; Write-Information 'info'";
_ = await PwshRunner.RunScript(script, lf.CreateLogger("Test"));
Assert.Equal(3, lf.Sink.LogEntries.Count());
Assert.Contains(lf.Sink.LogEntries, o => o.Message != null && o.Message.Equals("error"));
Assert.Contains(lf.Sink.LogEntries, o => o.Message != null && o.Message.Equals("warning"));
Assert.Contains(lf.Sink.LogEntries, o => o.Message != null && o.Message.Equals("info"));
}
public async Task CloseNuixConnectionAsync_WhenConnectionExists_ClosesConnection()
{
var state =
ConnectionTestsHelper.GetStateMonadWithConnection(TestLoggerFactory.Create());
var ct = new CancellationToken();
var actual = await state.CloseNuixConnectionAsync(null, ct);
var connection = state.GetVariable <NuixConnection>(NuixConnectionHelper.NuixVariableName);
Assert.True(actual.IsSuccess);
Assert.Equal(Unit.Default, actual);
Assert.True(connection.IsFailure);
}
public async Task DoesLoggingBehaviourWorksCorrectly()
{
var loggerFactory = TestLoggerFactory.Create();
var loggingBehaviour = new LoggingBehaviour <SampleRequest>(loggerFactory.CreateLogger <SampleRequest>());
var request = new SampleRequest
{
Version = "v2.0",
IsWorking = true
};
await loggingBehaviour.Process(request, CancellationToken.None);
loggerFactory.Sink.LogEntries.Should()
.ContainSingle(x => x.LogLevel == LogLevel.Information && x.Message == "eru Request: SampleRequest {Version = v2.0, IsWorking = True}");
}
public void UseScopeLogsScope()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.UseScope();
// Assert
Assert.Collection(loggerFactory.Sink.Scopes,
scope => Assert.Equal("This scope's answer is 42", scope.Message));
}
public void DoSomethingLogsCorrectParameter()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger <Sample>();
var sample = new Sample(logger);
// Act
sample.DoSomething();
// Assert
var log = Assert.Single(loggerFactory.Sink.LogEntries);
// Assert specific parameters in the log entry
LoggingAssert.Contains("number", 42, log.Properties);
}
public void UseLocalScopeLogsMessageWithScope()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.UseLocalScope();
// Assert
var log = Assert.Single(loggerFactory.Sink.LogEntries);
Assert.Equal("This scope's answer is 42", log.Scope.Message);
}
public async Task GetOrCreateNuixConnection_WhenReopenIsSet_DisposesOldConnection()
{
var loggerFactory = TestLoggerFactory.Create();
var state = ConnectionTestsHelper.GetStateMonadWithConnection(loggerFactory);
var originalConnection =
state.GetVariable <NuixConnection>(NuixConnectionHelper.NuixVariableName);
var createConnection = await state.GetOrCreateNuixConnection(null, true);
var processRef =
originalConnection.Value.ExternalProcess as ExternalProcessMock.ProcessReferenceMock;
Assert.True(createConnection.IsSuccess);
Assert.True(processRef !.IsDisposed);
}
public async void EntityFromPSObject_WhenBaseObjectIsHashtable_ReturnsEntity_Integration()
{
var lf = TestLoggerFactory.Create();
var script = @"@{prop1 = 'value1'; prop2 = 2} | Write-Output";
var result = await PwshRunner.GetEntityEnumerable(script, lf.CreateLogger("Test"))
.ToListAsync();
Assert.Single(result);
var val1 = result[0].TryGetValue("prop1").Map(x => x.GetPrimitiveString());
var val2 = result[0].TryGetValue("prop2").Map(x => x.ObjectValue);
Assert.Equal("value1", val1);
Assert.Equal(2, val2);
}
public void DoSomethingLogsUsingCorrectFormat()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var logger = loggerFactory.CreateLogger <Sample>();
var sample = new Sample(logger);
// Act
sample.DoSomething();
// Assert
var log = Assert.Single(loggerFactory.Sink.LogEntries);
// Assert the the log format template
Assert.Equal("The answer is {number}", log.OriginalFormat);
}
public void DoMoreLogsMessage()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.DoMore();
// Assert
Assert.Collection(loggerFactory.Sink.LogEntries,
l => Assert.Equal("More is less.", l.Message),
l => Assert.Equal("The answer is 42", l.Message));
}
public void DoMoreLogsFormat_NotCheckingNested()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create(options => options.FilterByTypeName <More>());
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.DoMore();
// Assert
var log = Assert.Single(loggerFactory.Sink.LogEntries);
Assert.Equal("More is less.", log.OriginalFormat);
}
public void UseScopeLogsCorrectOriginalFormat()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.UseScope();
// Assert
var scope = Assert.Single(loggerFactory.Sink.Scopes);
// Assert specific parameters in the log entry
Assert.Equal("This scope's answer is {number}", scope.OriginalFormat);
}
public void UseScopeLogsCorrectParameters()
{
// Arrange
var loggerFactory = TestLoggerFactory.Create();
var sampleLogger = loggerFactory.CreateLogger <Sample>();
var moreLogger = loggerFactory.CreateLogger <More>();
var more = new More(new Sample(sampleLogger), moreLogger);
// Act
more.UseScope();
// Assert
var scope = Assert.Single(loggerFactory.Sink.Scopes);
// Assert specific parameters in the log entry
LoggingAssert.Contains("number", 42, scope.Properties);
}
