public void ReturnsRoutesAndLogsWithAttributeWithBasepath()
{
var type = typeof(TypeWithBasePath);
var logger = new InMemoryLogger();
var basepath = type.GetRestResource().BasePath;
var scanner = new RouteScanner {
Logger = logger
};
logger.Logs.ShouldBeEmpty();
var routes = scanner.ScanType(type);
routes.ShouldNotBeNull();
routes.Count.ShouldBe(1);
var route = routes[0];
route.HttpMethod.ShouldBe(HttpMethod.GET);
route.PathInfo.ShouldBe($"{basepath}/stuff");
logger.Logs.Count.ShouldBe(2);
logger.Logs[0].Message.ShouldBe($"Generating routes from type {type.Name}");
logger.Logs[1].Message.ShouldBe($"Generated route {route.HttpMethod} {route.PathInfo} > {route.Name}");
}
public async Task AuthenticateWithInvalidCustomerPassword()
{
var containerType = Enum.Parse <ContainerType>(configuration.GetValue <string>("Container"));
if (containerType != ContainerType.BuiltIn)
{
return;
}
var password = TestingUtility.RandomString();
var invalidPassword = "******";
await WithCustomer(
client,
customerDraft => DefaultCustomerDraftWithPassword(customerDraft, password),
async customer =>
{
try
{
await client.ExecuteAsync(
new LoginCustomerCommand(customer.Email, invalidPassword));
}
catch (Exception ex)
{
Assert.IsType <ErrorResponseException>(ex);
Assert.DoesNotContain(ex.Message, invalidPassword);
Assert.DoesNotContain(ex.StackTrace, invalidPassword);
}
var log = InMemoryLogger.GetLogMessages();
Assert.NotEmpty(log);
Assert.DoesNotContain(log, invalidPassword);
});
}
public void ReturnsRoutesAndLogsWithBaseUrlArgument()
{
var assembly = GetTestAssembly();
var baseurl = "/api";
var logger = new InMemoryLogger();
var scanner = new RouteScanner {
Logger = logger
};
logger.Logs.ShouldBeEmpty();
var routes = scanner.ScanAssembly(assembly, baseurl);
routes.ShouldNotBeNull();
routes.Count.ShouldBe(8);
routes[0].HttpMethod.ShouldBe(HttpMethod.GET);
routes[0].PathInfo.ShouldBe($"{baseurl}/todo/list");
routes[4].HttpMethod.ShouldBe(HttpMethod.GET);
routes[4].PathInfo.ShouldBe($"{baseurl}/user/list");
logger.Logs.Count.ShouldBe(11);
logger.Logs[0].Message.ShouldBe($"Generating routes for assembly {assembly.GetName().Name}");
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabricksJobMetricsJobTests"/> class.
/// </summary>
public DatabricksJobMetricsJobTests(ITestOutputHelper outputWriter)
{
_outputWriter = outputWriter;
_config = TestConfig.Create();
_spyLogger = new InMemoryLogger();
_host = new TestHost(_config, ConfigureServices);
}
public static void CreateTestLogContent(out InMemoryLogger logger, out Dictionary <string, string> strMsg, out Dictionary <string, string> popTags)
{
logger = new InMemoryLogger();
strMsg =
new Dictionary <string, string>()
{
{ "Message", "the string message" },
{ "Category", "the string category" }
};
logger.Write("String message", strMsg);
var evaluator = new IdentityObjEval();
var inPoints = new List <TestHyperCube>();
inPoints.Add(createPoint(1.0, 2.0, 3.0));
inPoints.Add(createPoint(1.0, 2.2, 4.0));
inPoints.Add(createPoint(2.0, 3.0, 5.0));
var inScores = Array.ConvertAll(inPoints.ToArray(), (x => (IObjectiveScores)evaluator.EvaluateScore(x)));
popTags = new Dictionary <string, string>()
{
{ "Message", "initial population msg" },
{ "Category", "initial population category" }
};
logger.Write(inScores, popTags);
}
protected ITestingEngine AssertSucceeded(Configuration configuration, Action <PSharpRuntime> test)
{
InMemoryLogger logger = new InMemoryLogger();
BugFindingEngine engine = null;
try
{
engine = BugFindingEngine.Create(configuration, test);
engine.SetLogger(logger);
engine.Run();
var numErrors = engine.TestReport.NumOfFoundBugs;
Assert.True(numErrors == 0, GetBugReport(engine));
}
catch (Exception ex)
{
Assert.False(true, ex.Message + "\n" + ex.StackTrace);
}
finally
{
logger.Dispose();
}
return(engine);
}
public void ReturnsRoutesAndLogs()
{
//ReflectionTypeLoadException exception = null;
//var attempts = 0;
//do
//{
// attempts++;
// exception = null;
// try
// {
var logger = new InMemoryLogger();
var scanner = new RouteScanner {
Logger = logger
};
logger.Logs.ShouldBeEmpty();
var routes = scanner.Scan();
routes.ShouldNotBeNull();
routes.ShouldNotBeEmpty();
routes.Count.ShouldBeGreaterThanOrEqualTo(2);
logger.Logs.ShouldNotBeEmpty();
// }
// catch (ReflectionTypeLoadException ex)
// {
// exception = ex;
// Thread.Sleep(417);
// }
//} while (exception != null || attempts > 5);
//if (exception != null) throw exception;
}
public void CreateManualMappings()
{
//Arrange
var crudRepo = new EfRepository <EntityMapping>(_db, _authAdapter);
var logger = new InMemoryLogger();
var repo = new EntityMappingRepository(crudRepo, logger, null, null);
var trainingData = new List <Mapping>
{
new Mapping
{
Source = "Commodity",
Destination = "commodity"
}
};
//Act
var result = repo.CreateMapping(new ManualMapping
{
Mappings = trainingData,
SourceId = _sourceSystemId,
DestinationId = _destinationSystemId
});
//Assert
Assert.AreEqual(trainingData.Count, result);
}
public void LogMetricFinishedJobOutcome_WithDuplicateContextKey_DiscardsContextItem()
{
// Arrange
var spyLogger = new InMemoryLogger <DatabricksJobMetricsJob>();
string metricName = BogusGenerator.Random.Word();
var resultState = BogusGenerator.PickRandom <RunResultState>();
var run = new Run {
State = new RunState {
ResultState = resultState
}
};
var jobRun = new JobRun(BogusGenerator.Random.Word(), run);
string discardedValue = $"discarded-{Guid.NewGuid()}";
string includedValue = $"included-{Guid.NewGuid()}";
var context = new Dictionary <string, object>
{
["Outcome"] = discardedValue,
["NewKey"] = includedValue
};
// Act
spyLogger.LogMetricFinishedJobOutcome(metricName, jobRun, context);
// Assert
Assert.DoesNotContain(spyLogger.Messages, msg => msg.Contains(discardedValue));
Assert.Contains(spyLogger.Messages, msg => msg.Contains(includedValue));
}
public BotHarness(BotMeta meta, string botDir, string workDir)
: base(meta.NickName ?? meta.Author ?? meta.Email)
{
BotMeta = meta;
BotDir = botDir;
WorkDir = workDir;
_inMemoryLogger = new InMemoryLogger();
Logger = _inMemoryLogger;
switch (meta.BotType)
{
case BotMeta.BotTypes.CSharp:
case BotMeta.BotTypes.CPlusPlus:
case BotMeta.BotTypes.FSharp:
_botRunner = new DotNetRunner(this);
break;
case BotMeta.BotTypes.Python2:
case BotMeta.BotTypes.Python3:
_botRunner = new PythonRunner(this);
break;
case BotMeta.BotTypes.Java:
_botRunner = new JavaRunner(this);
break;
case BotMeta.BotTypes.JavaScript:
_botRunner = new JavaScriptRunner(this);
break;
default:
throw new ArgumentException("Invalid bot type " + meta.BotType);
}
}
protected void AssertFailedWithException(Configuration configuration, Action <PSharpRuntime> test, Type exceptionType)
{
Assert.True(exceptionType.IsSubclassOf(typeof(Exception)), "Please configure the test correctly. " +
$"Type '{exceptionType}' is not an exception type.");
InMemoryLogger logger = new InMemoryLogger();
try
{
var engine = BugFindingEngine.Create(configuration, test);
engine.SetLogger(logger);
engine.Run();
var numErrors = engine.TestReport.NumOfFoundBugs;
Assert.Equal(1, numErrors);
var exception = this.RemoveNonDeterministicValuesFromReport(engine.TestReport.BugReports.First()).
Split(new[] { '\r', '\n' }).FirstOrDefault();
Assert.Contains("'" + exceptionType.ToString() + "'", exception);
}
catch (Exception ex)
{
Assert.False(true, ex.Message);
}
finally
{
logger.Dispose();
}
}
public MasterSystem(ProgramArguments arguments, int size)
{
int rank = 0;
LoadOptimiserParams(arguments);
sceOptions = SceOptions.RndInSubComplex;
if (arguments.SceOptions == "full")
{
sceOptions |= SceOptions.ReflectionRandomization;
}
OutputPath = arguments.OutputPath;
// Ensure existance of some locations that are assumed to exist when writing the results
if (!OutputPath.Exists)
{
OutputPath.Create();
}
RosenbrockIterations = arguments.RosenbrockIterations.Clamp(MinRosenbrockIterations, MaxRosenbrockIterations);
WallClock = arguments.WallClockHours.Clamp(MinWallClock, MaxWallClock);
ConvergenceCriterionCvThreshold = arguments.ConvergenceCriterionCvThreshold.Clamp(MinConvergenceThreshold, MaxConvergenceThreshold);
TerminationCriterion = (TerminationCriteria)Enum.Parse(typeof(TerminationCriteria), arguments.TerminationCriterion);
OptimisationMethod = (OptimisationMethods)Enum.Parse(typeof(OptimisationMethods), arguments.OptimisationMethod);
SeedParametersFile = arguments.ParameterDefinitions.FullName;
LogFileName = Path.Combine(arguments.OutputPath.FullName, arguments.LogFile);
OutputFileName = Path.Combine(arguments.OutputPath.FullName, arguments.ResultsFile);
TemplateParameterSet = GridModelHelper.LoadParameterSpace(arguments.ParameterDefinitions.FullName);
MpiSysConfig[] seedsPopulation = GridModelHelper.LoadParameterSets(arguments.SeedParameterSets, TemplateParameterSet);
evaluator = new MultiCatchmentCompositeObjectiveEvaluator(
arguments.GlobalDefinition, arguments.ObjectiveDefinition, arguments.CreateCompositeEvaluator(), rank, size);
InMemoryLogger = new InMemoryLogger();
optimisationEngine = CreateEngine(evaluator, TemplateParameterSet, seedsPopulation, InMemoryLogger, arguments.Name, arguments.InitString);
}
internal static void Failed(Configuration configuration, string test, int numExpectedErrors, string expectedOutput, bool isPSharpProgram = true)
{
InMemoryLogger logger = new InMemoryLogger();
try
{
var context = CompileTest(configuration, test, isPSharpProgram);
var engine = StaticAnalysisEngine.Create(context, logger).Run();
var numErrors = engine.ErrorReporter.ErrorCount;
Xunit.Assert.Equal(numExpectedErrors, numErrors);
if (!string.IsNullOrEmpty(expectedOutput))
{
var actual = logger.ToString();
Xunit.Assert.Equal(
expectedOutput.Replace(Environment.NewLine, string.Empty),
actual.Substring(0, actual.IndexOf(Environment.NewLine)));
}
}
finally
{
logger.Dispose();
}
}
protected void AssertFailedAndWarning(Configuration configuration, string test, int numExpectedErrors, int numExpectedWarnings, string expectedOutput, bool isPSharpProgram = true)
{
InMemoryLogger logger = new InMemoryLogger();
configuration.ShowWarnings = true;
try
{
var context = CompileTest(configuration, test, isPSharpProgram);
var engine = StaticAnalysisEngine.Create(context, logger).Run();
var numErrors = engine.ErrorReporter.ErrorCount;
var numWarnings = engine.ErrorReporter.WarningCount;
Assert.Equal(numExpectedErrors, numErrors);
Assert.Equal(numExpectedWarnings, numWarnings);
if (!string.IsNullOrEmpty(expectedOutput))
{
var actual = logger.ToString();
Assert.Equal(expectedOutput.Replace(Environment.NewLine, string.Empty),
actual.Replace(Environment.NewLine, string.Empty));
}
}
finally
{
logger.Dispose();
}
}
public async Task ConfigureSecretStore_WithAuditingIncrement_LogsSecurityEvent()
{
// Arrange
string secretName = "MySecret";
var stubProvider = new InMemorySecretProvider((secretName, $"secret-{Guid.NewGuid()}"));
var spyLogger = new InMemoryLogger();
var builder = new HostBuilder();
builder.ConfigureLogging(logging => logging.AddProvider(new TestLoggerProvider(spyLogger)));
// Act
builder.ConfigureSecretStore((config, stores) =>
{
stores.AddProvider(stubProvider)
.WithAuditing(options => options.EmitSecurityEvents = false)
.WithAuditing(options => options.EmitSecurityEvents = true);
});
// Assert
IHost host = builder.Build();
var secretProvider = host.Services.GetRequiredService <ISecretProvider>();
await secretProvider.GetRawSecretAsync(secretName);
#if NET6_0
Assert.Equal(1, spyLogger.Messages.Count(msg => msg.StartsWith("Get Secret")));
#else
Assert.Equal(1, spyLogger.Messages.Count(msg => msg.StartsWith("Events") && msg.Contains("Security")));
#endif
}
public ScheduleApplication(IntPtr javaReference, JniHandleOwnership transfer)
: base(javaReference, transfer)
{
Logger = new InMemoryLogger();
Logger.Log(
"SmtuSchedule version {0}, running on {1} {2} (Android {4} – API {3}).",
GetVersion(),
Build.Manufacturer,
Build.Model,
Build.VERSION.Sdk,
Build.VERSION.Release
);
// У AndroidEnvironment.UnhandledExceptionRaiser трассировка стека подробнее,
// чем у AppDomain.CurrentDomain.UnhandledException.
AndroidEnvironment.UnhandledExceptionRaiser += (s, e) =>
{
Logger.Log(e.Exception);
SaveLog(true);
Crashes.TrackError(e.Exception);
};
Preferences = new Preferences(this);
IsInitialized = false;
}
public void AutomatedMapping()
{
var db = new EntityMapperDbContext();
var auth = new IdentityAuthAdapter();
var repository = new EfRepository <EntityMapping>(db, auth);
var logger = new InMemoryLogger();
var sut = new EntityMappingRepository(repository, logger, null, null);
var automatedMapping = new AutomatedMapping
{
DestinationId = 177,
SourceId = 176,
LearningResult = new LearningResult(new List <LearntMapping>
{
new LearntMapping
{
Mapping = new Mapping
{
Source = "qmob_commodity",
Destination = "qcommodity"
}
}
})
};
//act
var result = sut.CreateMapping(automatedMapping);
//assert
Assert.AreEqual(1, result.Count());
}
public void TestCustomLogger()
{
InMemoryLogger log = new InMemoryLogger();
var config = GetConfiguration().WithVerbosityEnabled().WithTestingIterations(3);
TestingEngine engine = TestingEngine.Create(config, (ICoyoteRuntime runtime) =>
{
runtime.Logger.WriteLine("Hi mom!");
});
engine.Logger = log;
engine.Run();
var result = log.ToString();
result = result.RemoveNonDeterministicValues();
var expected = @"... Task 0 is using 'random' strategy (seed:4005173804).
..... Iteration #1
<TestLog> Running test.
Hi mom!
..... Iteration #2
<TestLog> Running test.
Hi mom!
..... Iteration #3
<TestLog> Running test.
Hi mom!
";
expected = expected.RemoveNonDeterministicValues();
Assert.Equal(expected, result);
}
public static void CreateTestLogContent(out InMemoryLogger logger, out Dictionary<string, string> strMsg, out Dictionary<string, string> popTags)
{
logger = new InMemoryLogger();
strMsg =
new Dictionary<string, string>()
{
{"Message", "the string message"},
{"Category", "the string category"}
};
logger.Write("String message", strMsg);
var evaluator = new IdentityObjEval();
var inPoints = new List<TestHyperCube>();
inPoints.Add(createPoint(1.0, 2.0, 3.0));
inPoints.Add(createPoint(1.0, 2.2, 4.0));
inPoints.Add(createPoint(2.0, 3.0, 5.0));
var inScores = Array.ConvertAll(inPoints.ToArray(), (x => (IObjectiveScores)evaluator.EvaluateScore(x)));
popTags = new Dictionary<string, string>()
{
{"Message", "initial population msg"},
{"Category", "initial population category"}
};
logger.Write(inScores, popTags);
}
public void Get()
{
//arrange
//Todo: Use Autofacs config for this initialization
AutoMapperConfig.RegisterMappings();
var db = new EntityMapperDbContext();
var authAdapter = new IdentityAuthAdapter();
var repo = new EfRepository <EntityMapping>(db, authAdapter);
var _logger = new InMemoryLogger();
EfRepository <MappingOrigin> originRepo = new EfRepository <MappingOrigin>(db, authAdapter);
EfRepository <Entity> entityRepo = new EfRepository <Entity>(db, authAdapter);
IMappingRepository mappingRepository = new EntityMappingRepository(repo, _logger, null, null);
var sut = new EntityMappingsController(repo, originRepo, entityRepo, mappingRepository);
var dbRecordCount = db.EntityMappings.Count();
//act
var actionResult = sut.Get();
var result = actionResult as OkNegotiatedContentResult <List <EntityMappingViewModel> >;
//assert
Assert.NotNull(result);
var content = result.Content;
Assert.AreEqual(dbRecordCount, content.Count);
}
static void Main(string[] args)
{
var companyCoordinate = new Coordinate(53.339428, -6.257664);
var maxDistanceFromCompany = 100;
var fileName = "customerfile.txt";
var logger = new InMemoryLogger();
var serviceProvider = BuildDi(logger);
var app = serviceProvider.GetRequiredService <ICustomerInvitationApp>();
var eligibleCustomers = app.GetEligibleCustomer(companyCoordinate, maxDistanceFromCompany, fileName);
foreach (var customer in eligibleCustomers.OrderBy(x => x.Customer.UserId))
{
Console.WriteLine($"User Id: {customer.Customer.UserId} - Name: {customer.Customer.Name} - Distance: {customer.DistanceInKm} kms");
}
Console.WriteLine("\n\n\n\nPrint Error Log :");
foreach (var debugMessage in logger.LogItems.Where(x => x.LogLevel == LogLevel.Error))
{
Console.WriteLine(debugMessage.GetLogMessage());
}
Console.WriteLine("\n\n\n\nPrint Debug Log :");
foreach (var debugMessage in logger.LogItems.Where(x => x.LogLevel == LogLevel.Debug))
{
Console.WriteLine(debugMessage.GetLogMessage());
}
}
public static ILoggingBuilder AddInMemory(this ILoggingBuilder builder)
{
var logger = new InMemoryLogger();
builder.Services.AddSingleton(logger);
return(builder.AddProvider(new InMemLoggerProvider(logger)));
}
protected void AssertFailed(Configuration configuration, Action <PSharpRuntime> test, int numExpectedErrors, ISet <string> expectedOutputs)
{
InMemoryLogger logger = new InMemoryLogger();
try
{
var bfEngine = BugFindingEngine.Create(configuration, test);
bfEngine.SetLogger(logger);
bfEngine.Run();
CheckErrors(bfEngine, numExpectedErrors, expectedOutputs);
if (!configuration.EnableCycleDetection)
{
var rEngine = ReplayEngine.Create(configuration, test, bfEngine.ReproducableTrace);
rEngine.SetLogger(logger);
rEngine.Run();
Assert.True(rEngine.InternalError.Length == 0, rEngine.InternalError);
CheckErrors(rEngine, numExpectedErrors, expectedOutputs);
}
}
catch (Exception ex)
{
Assert.False(true, ex.Message + "\n" + ex.StackTrace);
}
finally
{
logger.Dispose();
}
}
protected void AssertFailedWithException(Configuration configuration, Action <PSharpRuntime> test, Type exceptionType, bool replay)
{
Assert.True(exceptionType.IsSubclassOf(typeof(Exception)), "Please configure the test correctly. " +
$"Type '{exceptionType}' is not an exception type.");
InMemoryLogger logger = new InMemoryLogger();
try
{
var bfEngine = BugFindingEngine.Create(configuration, test);
bfEngine.SetLogger(logger);
bfEngine.Run();
CheckErrors(bfEngine, exceptionType);
if (replay && !configuration.EnableCycleDetection)
{
var rEngine = ReplayEngine.Create(configuration, test, bfEngine.ReproducableTrace);
rEngine.SetLogger(logger);
rEngine.Run();
Assert.True(rEngine.InternalError.Length == 0, rEngine.InternalError);
CheckErrors(rEngine, exceptionType);
}
}
catch (Exception ex)
{
Assert.False(true, ex.Message + "\n" + ex.StackTrace);
}
finally
{
logger.Dispose();
}
}
public void ReturnsRoutesAndLogsWithInclusions()
{
//ReflectionTypeLoadException exception = null;
//var attempts = 0;
//do
//{
// attempts++;
// exception = null;
// try
// {
var logger = new InMemoryLogger();
var scanner = new RouteScanner {
Logger = logger
};
scanner.Include(Assembly.GetExecutingAssembly());
logger.Logs.ShouldBeEmpty();
var routes = scanner.Scan();
routes.ShouldNotBeNull();
routes.Count.ShouldBe(2);
logger.Logs.ShouldNotBeEmpty();
// }
// catch (ReflectionTypeLoadException ex)
// {
// exception = ex;
// Thread.Sleep(231);
// }
//} while (exception != null || attempts > 5);
//if (exception != null) throw exception;
}
/// <summary>
/// Constructs a reproducable trace.
/// </summary>
/// <param name="runtime">BugFindingRuntime</param>
/// <param name="logger">InMemoryLogger</param>
private void ConstructReproducableTrace(BugFindingRuntime runtime, InMemoryLogger logger)
{
this.ReadableTrace = logger.ToString();
this.ReadableTrace += this.TestReport.GetText(base.Configuration, "<StrategyLog>");
this.BugTrace = runtime.BugTrace;
StringBuilder stringBuilder = new StringBuilder();
if (this.Strategy.IsFair())
{
stringBuilder.Append("--fair-scheduling").Append(Environment.NewLine);
}
if (base.Configuration.CacheProgramState)
{
stringBuilder.Append("--state-caching").Append(Environment.NewLine);
stringBuilder.Append("--liveness-temperature-threshold:" +
base.Configuration.LivenessTemperatureThreshold).
Append(Environment.NewLine);
}
else
{
stringBuilder.Append("--liveness-temperature-threshold:" +
base.Configuration.LivenessTemperatureThreshold).
Append(Environment.NewLine);
}
if (!base.Configuration.TestMethodName.Equals(""))
{
stringBuilder.Append("--test-method:" +
base.Configuration.TestMethodName).
Append(Environment.NewLine);
}
for (int idx = 0; idx < runtime.ScheduleTrace.Count; idx++)
{
ScheduleStep step = runtime.ScheduleTrace[idx];
if (step.Type == ScheduleStepType.SchedulingChoice)
{
stringBuilder.Append($"{step.ScheduledMachineId.Type}" +
$"({step.ScheduledMachineId.Value})");
}
else if (step.BooleanChoice != null)
{
stringBuilder.Append(step.BooleanChoice.Value);
}
else
{
stringBuilder.Append(step.IntegerChoice.Value);
}
if (idx < runtime.ScheduleTrace.Count - 1)
{
stringBuilder.Append(Environment.NewLine);
}
}
this.ReproducableTrace = stringBuilder.ToString();
}
public void Log_NoErrorLogged_ReturnsEmptyList()
{
InMemoryLogger.ClearLog();
var log = new InMemoryLogger();
Assert.That(InMemoryLogger.Log, Is.Empty);
}
public void BeginRoutingMessageLogged()
{
var expected = $"Routing Request : {MessageText}";
var logger = new InMemoryLogger();
logger.BeginRouting(MessageText);
logger.Logs[0].Message.ShouldBe(expected);
}
public void LogExceptionSetsExceptionDetails()
{
var logger = new InMemoryLogger();
logger.LogException(Severity.Warning, GenerateException());
var logEventFields = logger.Events[0].ToDictionary();
Assert.Equal("Oh no!", logEventFields["message"]);
}
public void RouteInvokedMessageLogged()
{
var expected = $"Route Invoked : {MessageText}";
var logger = new InMemoryLogger();
logger.RouteInvoked(MessageText);
logger.Logs[0].Message.ShouldBe(expected);
}
public void LogExceptionSetsSeverity()
{
var logger = new InMemoryLogger();
logger.LogException(Severity.Warning, GenerateException());
var logEventFields = logger.Events[0].ToDictionary();
Assert.Equal("warning", logEventFields["severity"]);
}
private static void InitializeLogging()
{
LoggingHelper.InitFileLogger("PDFCreator", LoggingLevel.Error);
var inMemoryLogger = new InMemoryLogger(100);
inMemoryLogger.Register();
_errorReportHelper = new ErrorReportHelper(inMemoryLogger);
}
public void RoutingCompleteMessageLogged()
{
var expected = $"Routing Complete : {MessageText}";
var logger = new InMemoryLogger();
logger.EndRouting(MessageText);
logger.Logs[0].Message.ShouldBe(expected);
}
public void LoggedEventsCanBeRetrieved()
{
var logger = new InMemoryLogger();
var logEvent = LogEvent.OfSeverity(Severity.Error);
logger.Log(logEvent);
Assert.Equal(1, logger.Events.Count);
Assert.Equal(logEvent, logger.Events[0]);
}
