public static void InitializeLogs(Action <InMemoryLoggerProvider, ILogger> action) { var services = new ServiceCollection(); services.AddLogging(); var logs = new InMemoryLoggerProvider(); services.AddSingleton <ILoggerProvider>(logs); using var provider = services.BuildServiceProvider(); var logger = provider.GetRequiredService <ILogger <BasicUsageUnitTests> >(); action(logs, logger); }
public void Test_LogLevel_Debug() { //arrange var loggerProvider = new InMemoryLoggerProvider(); LogManager.LoggerFactory.AddProvider(loggerProvider); var poco = new Poco(); //act poco.DebugLogSomething(); //assert Assert.Contains("Something happened.", loggerProvider.Logs["Couchbase.UnitTests.Core.Logging.LogManagerTests.Poco"][0]); }
public void CannotValidatePostActionWithExtraInstructionLocalization() { SimpleConfigModel baseConfig = new SimpleConfigModel() { Identity = "Test", PostActionModels = new List <PostActionModel> { new PostActionModel() { Id = "pa0", Description = "text", ActionId = Guid.NewGuid(), ManualInstructionInfo = new List <ManualInstructionModel>() { new ManualInstructionModel("first", "my text"), new ManualInstructionModel("second", "my text"), } }, } }; List <(LogLevel, string)> loggedMessages = new List <(LogLevel, string)>(); InMemoryLoggerProvider loggerProvider = new InMemoryLoggerProvider(loggedMessages); IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true, addLoggerProviders: new[] { loggerProvider }); string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder(); string localizationFilename = string.Format(DefaultLocalizeConfigRelativePath, "de-DE"); WriteFile( Path.Combine(tempFolder, localizationFilename), "{ \"postActions/pa0/manualInstructions/first/text\": \"localized\", \"postActions/pa0/manualInstructions/extra/text\": \"extraLoc\" }", environmentSettings); using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings); var templateConfig = new RunnableProjectConfig(environmentSettings, A.Fake <IGenerator>(), baseConfig); var localizationFile = mountPoint.FileInfo(localizationFilename); var localizationModel = LocalizationModelDeserializer.Deserialize(localizationFile !); Assert.False(templateConfig.VerifyLocalizationModel(localizationModel, localizationFile)); var warningMessages = loggedMessages.Where(log => log.Item1 == LogLevel.Warning); Assert.Single(warningMessages); Assert.Contains( string.Format(LocalizableStrings.Authoring_InvalidManualInstructionLocalizationIndex, "extra", "pa0"), warningMessages.Single().Item2); Assert.Contains(localizationFilename, warningMessages.Single().Item2); }
public async Task Evaluate_MultipleConflictingProviders() { var config = new { identity = "test-constraint-01", constraints = new { specVersions = new { type = "workload", args = new[] { "workloadA", "workloadB" } } } }; var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config)); IWorkloadsInfoProvider workloadInfoProviderA = A.Fake <IWorkloadsInfoProvider>(); A.CallTo(() => workloadInfoProviderA .GetInstalledWorkloadsAsync(A <CancellationToken> ._)) .Returns(Task.FromResult(new[] { "workload", "workloadA" }.Select(s => new WorkloadInfo(s, $"D:{s}")))); IWorkloadsInfoProvider workloadInfoProviderB = A.Fake <IWorkloadsInfoProvider>(); A.CallTo(() => workloadInfoProviderB .GetInstalledWorkloadsAsync(A <CancellationToken> ._)) .Returns(Task.FromResult(new[] { "workload", "workloadA", "workloadB" }.Select(s => new WorkloadInfo(s, $"D:{s}")))); IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>(); A.CallTo(() => settings.Components.OfType <IWorkloadsInfoProvider>()).Returns(new[] { workloadInfoProviderA, workloadInfoProviderB }); A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new WorkloadConstraintFactory() }); List <(LogLevel, string)> messagesCollection = new(); ILogger logger = new InMemoryLoggerProvider(messagesCollection).CreateLogger("x"); A.CallTo(() => settings.Host.Logger).Returns(logger); var constraintManager = new TemplateConstraintManager(settings); var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false); Assert.Equal(TemplateConstraintResult.Status.NotEvaluated, evaluateResult.EvaluationStatus); Assert.Equal(0, messagesCollection.Count(t => t.Item1 >= LogLevel.Warning)); Assert.StartsWith("The constraint 'workload' failed to initialize", evaluateResult.LocalizedErrorMessage); }
public void CannotReadConstraint_WhenArrayIsDenfined() { var json = new { identity = "test", constraints = new { one = new[] { "one", "two" } } }; List <(LogLevel, string)> loggedMessages = new List <(LogLevel, string)>(); InMemoryLoggerProvider loggerProvider = new InMemoryLoggerProvider(loggedMessages); var model = SimpleConfigModel.FromJObject(JObject.FromObject(json), loggerProvider.CreateLogger("test")); Assert.Empty(model.Constraints); Assert.Single(loggedMessages); Assert.Equal("'constraints' should contain objects.", loggedMessages.Single().Item2); }
public void SetUp() { _Container = new Container(); _Container.Register <IServiceWithTransaction, SimpleServiceWithTransaction>(Reuse.Scoped); _Container.Register <SimpleServiceWithTransaction>(Reuse.Scoped); _Container.Register <SimpleServiceWithTransaction2>(Reuse.Scoped); _Container.Register <EmptyServiceWithInfo>(Reuse.Scoped); _Container.Register <ServiceAccessor>(Reuse.Scoped); // The same setup configuration as TransactionInterceptor: _Container.Register <ServiceWithParentInfo>(Reuse.Transient, setup: Setup.With(asResolutionCall: true)); // In-memory logging _LoggerProvider = new InMemoryLoggerProvider(); _LoggerFactory = new LoggerFactory(new[] { _LoggerProvider }); _Container.UseInstance <ILoggerFactory>(_LoggerFactory); _Container.AddAutoTx(); }
public void CannotReadConstraint_WhenTypeIsNotSet() { var json = new { identity = "test", constraints = new { one = new { args = "arg" } } }; List <(LogLevel, string)> loggedMessages = new List <(LogLevel, string)>(); InMemoryLoggerProvider loggerProvider = new InMemoryLoggerProvider(loggedMessages); var model = SimpleConfigModel.FromJObject(JObject.FromObject(json), loggerProvider.CreateLogger("test")); Assert.Empty(model.Constraints); Assert.Single(loggedMessages); Assert.Equal($"Constraint definition '{JObject.FromObject(new { args = "arg" }).ToString()}' does not contain mandatory property 'type'.", loggedMessages.Single().Item2); }
public static ILoggingBuilder AddInMemory(this ILoggingBuilder builder) { InMemoryLoggerProvider = new InMemoryLoggerProvider(); builder.AddProvider(InMemoryLoggerProvider); return(builder); }
/// <summary> /// A default constructor. /// </summary> /// <param name="fixture">The fixture that holds the testing setup.</param> public TestStateGrainTests(IntegrationTestFixture fixture) { TestStateClient = fixture.ServicesProvider.GetService <TestStateClient>(); InMemoryLoggerProvider = fixture.InMemoryLoggerProvider; }
public InMemoryLogger(InMemoryLoggerProvider provider, string categoryName) { _provider = provider; _categoryName = categoryName; }
public void PerformTemplateValidation_ChoiceValuesValidation(string paramDefintion, bool isMultichoice, bool expectedToBeValid) { // // Template content preparation // Guid inputTestGuid = new Guid("12aa8f4e-a4aa-4ac1-927c-94cb99485ef1"); string contentFileNamePrefix = "content - "; JObject choiceParam = JObject.Parse(paramDefintion); choiceParam["AllowMultipleValues"] = isMultichoice; SimpleConfigModel config = new SimpleConfigModel() { Identity = "test", Name = "name", ShortNameList = new [] { "shortName" }, Symbols = new Dictionary <string, ISymbolModel>() { { "ParamA", new ParameterSymbol(choiceParam, null) } } }; IDictionary <string, string?> templateSourceFiles = new Dictionary <string, string?>(); // template.json templateSourceFiles.Add(TestFileSystemHelper.DefaultConfigRelativePath, config.ToJObject().ToString()); //content foreach (string guidFormat in GuidMacroConfig.DefaultFormats.Select(c => c.ToString())) { templateSourceFiles.Add(contentFileNamePrefix + guidFormat, inputTestGuid.ToString(guidFormat)); } // // Dependencies preparation and mounting // List <(LogLevel, string)> loggedMessages = new List <(LogLevel, string)>(); InMemoryLoggerProvider loggerProvider = new InMemoryLoggerProvider(loggedMessages); IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment(addLoggerProviders: new [] { loggerProvider }); string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment); string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment); RunnableProjectGenerator rpg = new RunnableProjectGenerator(); TestFileSystemHelper.WriteTemplateSource(environment, sourceBasePath, templateSourceFiles); IMountPoint? sourceMountPoint = TestFileSystemHelper.CreateMountPoint(environment, sourceBasePath); RunnableProjectConfig runnableConfig = new RunnableProjectConfig(environment, rpg, config, sourceMountPoint.FileInfo(TestFileSystemHelper.DefaultConfigRelativePath)); if (expectedToBeValid) { runnableConfig.PerformTemplateValidation(); Assert.Empty(loggedMessages.Where(l => l.Item1 >= LogLevel.Warning)); } else { var exc = Assert.Throws <TemplateValidationException>(runnableConfig.PerformTemplateValidation); Assert.Contains("The template configuration ", exc.Message); Assert.Contains(" is not valid.", exc.Message); Assert.Single(loggedMessages.Where(l => l.Item1 >= LogLevel.Warning)); string errorMessage = loggedMessages.First(l => l.Item1 >= LogLevel.Warning).Item2; Assert.Contains( "Choice parameter is invalid. It allows multiple values ('AllowMultipleValues=true'), while some of the configured choices contain separator characters ('|', ','). Invalid choices: {First|Choice}", errorMessage); } }