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); }