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