public async Task SpecializeAsync_ReadOnly_KeepsProcessAlive(string runtime, string languageWorkerName) { var testMetricsLogger = new TestMetricsLogger(); _testEnvironment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, runtime); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteZipDeployment, "1"); _rpcWorkerChannelManager = new WebHostRpcWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _rpcWorkerChannelFactory, _optionsMonitor, testMetricsLogger, _workerOptionsMonitor, _emptyConfig); IRpcWorkerChannel workerChannel = CreateTestChannel(languageWorkerName); await _rpcWorkerChannelManager.SpecializeAsync(); // Wait for debouce task to start await TestHelpers.Await(() => { return(testMetricsLogger.EventsBegan.Contains(MetricEventNames.SpecializationScheduleShutdownStandbyChannels) && testMetricsLogger.EventsEnded.Contains(MetricEventNames.SpecializationScheduleShutdownStandbyChannels)); }, pollingInterval : 500); // Verify logs var traces = _testLogger.GetLogMessages(); var functionLoadLogs = traces.Where(m => string.Equals(m.FormattedMessage, "SendFunctionEnvironmentReloadRequest called")); Assert.True(functionLoadLogs.Count() == 1); // Verify channel var initializedChannel = await _rpcWorkerChannelManager.GetChannelAsync(languageWorkerName); Assert.Equal(workerChannel, initializedChannel); }
public async Task SpecializeAsync_LanguageWorkerArguments_KillsProcess(string languageWorkerName, string argument) { var testMetricsLogger = new TestMetricsLogger(); _testEnvironment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, languageWorkerName); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionsExtensionVersion, "~3"); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteZipDeployment, "1"); var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { [$"{RpcWorkerConstants.LanguageWorkersSectionName}:{languageWorkerName}:{WorkerConstants.WorkerDescriptionArguments}"] = argument }) .Build(); _rpcWorkerChannelManager = new WebHostRpcWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _rpcWorkerChannelFactory, _optionsMonitor, testMetricsLogger, _workerOptionsMonitor, config); IRpcWorkerChannel workerChannel = CreateTestChannel(languageWorkerName); await _rpcWorkerChannelManager.SpecializeAsync(); // Verify logs var traces = _testLogger.GetLogMessages(); Assert.True(traces.Count() == 0); // Verify channel var initializedChannel = await _rpcWorkerChannelManager.GetChannelAsync(languageWorkerName); Assert.Null(initializedChannel); }
public async Task SpecializeAsync_Java_ReadOnly_KeepsProcessAlive() { var testMetricsLogger = new TestMetricsLogger(); _testEnvironment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, RpcWorkerConstants.JavaLanguageWorkerName); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteZipDeployment, "1"); _rpcWorkerChannelManager = new WebHostRpcWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _rpcWorkerChannelFactory, _optionsMonitor, testMetricsLogger); IRpcWorkerChannel javaWorkerChannel = CreateTestChannel(RpcWorkerConstants.JavaLanguageWorkerName); await _rpcWorkerChannelManager.SpecializeAsync(); Assert.True(testMetricsLogger.EventsBegan.Contains(MetricEventNames.SpecializationScheduleShutdownStandbyChannels) && testMetricsLogger.EventsEnded.Contains(MetricEventNames.SpecializationScheduleShutdownStandbyChannels)); // Verify logs var traces = _testLogger.GetLogMessages(); var functionLoadLogs = traces.Where(m => string.Equals(m.FormattedMessage, "SendFunctionEnvironmentReloadRequest called")); Assert.True(functionLoadLogs.Count() == 1); // Verify channel var initializedChannel = await _rpcWorkerChannelManager.GetChannelAsync(RpcWorkerConstants.JavaLanguageWorkerName); Assert.Equal(javaWorkerChannel, initializedChannel); }
public async Task GetHostSecrets_AddMetrics() { using (var directory = new TempDirectory()) { string expectedTraceMessage = Resources.TraceNonDecryptedHostSecretRefresh; string hostSecretsJson = @"{ 'masterKey': { 'name': 'master', 'value': 'cryptoError', 'encrypted': true }, 'functionKeys': [], 'systemKeys': [] }"; File.WriteAllText(Path.Combine(directory.Path, ScriptConstants.HostMetadataFileName), hostSecretsJson); HostSecretsInfo hostSecrets; TestMetricsLogger metricsLogger = new TestMetricsLogger(); using (var secretManager = CreateSecretManager(directory.Path, metricsLogger: metricsLogger, simulateWriteConversion: true, setStaleValue: false)) { hostSecrets = await secretManager.GetHostSecretsAsync(); } string eventName = string.Format(MetricEventNames.SecretManagerGetHostSecrets, typeof(FileSystemSecretsRepository).Name.ToLower()); metricsLogger.EventsBegan.Single(e => string.Equals(e, eventName)); metricsLogger.EventsEnded.Single(e => string.Equals(e.ToString(), eventName)); } }
public void ReadWorkerProviderFromConfig_Concatenate_ArgsFromSettings_ArgsFromWorkerConfig() { string[] argsFromConfig = new string[] { "--expose-http2", "--no-deprecation" }; var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, argsFromConfig) }; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig Dictionary <string, string> keyValuePairs = new Dictionary <string, string> { [$"{RpcWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{WorkerConstants.WorkerDescriptionArguments}"] = "--inspect=5689" }; var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), testMetricsLogger, null, keyValuePairs); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); RpcWorkerConfig workerConfig = workerConfigs.Single(); Assert.Equal(Path.Combine(rootPath, testLanguage, $"{RpcWorkerConfigTestUtilities.TestWorkerPathInWorkerConfig}.{testLanguage}"), workerConfig.Description.DefaultWorkerPath); Assert.True(workerConfig.Description.Arguments.Count == 3); Assert.True(workerConfig.Description.Arguments.Contains("--inspect=5689")); Assert.True(workerConfig.Description.Arguments.Contains("--no-deprecation")); Assert.True(workerConfig.Description.Arguments.Contains("--expose-http2")); }
public FunctionInstanceLoggerTests() { var metadataManager = new Mock <IFunctionMetadataManager>(MockBehavior.Strict); _metrics = new TestMetricsLogger(); _functionInstanceLogger = new FunctionInstanceLogger(metadataManager.Object, _metrics); }
public async Task GetHostSecrets_AddMetrics() { using (var directory = new TempDirectory()) { string expectedTraceMessage = Resources.TraceNonDecryptedHostSecretRefresh; string hostSecretsJson = @"{ 'masterKey': { 'name': 'master', 'value': 'cryptoError', 'encrypted': true }, 'functionKeys': [], 'systemKeys': [] }"; File.WriteAllText(Path.Combine(directory.Path, ScriptConstants.HostMetadataFileName), hostSecretsJson); Mock <IKeyValueConverterFactory> mockValueConverterFactory = GetConverterFactoryMock(true, false); HostSecretsInfo hostSecrets; ISecretsRepository repository = new FileSystemSecretsRepository(directory.Path); TestMetricsLogger metricsLogger = new TestMetricsLogger(); using (var secretManager = new SecretManager(repository, mockValueConverterFactory.Object, null, metricsLogger, _hostNameProvider)) { hostSecrets = await secretManager.GetHostSecretsAsync(); } string eventName = string.Format(MetricEventNames.SecretManagerGetHostSecrets, repository.GetType().Name.ToLower()); metricsLogger.EventsBegan.Single(e => string.Equals(e, eventName)); metricsLogger.EventsEnded.Single(e => string.Equals(e.ToString(), eventName)); } }
public PackageDownloadHandlerTests() { _httpClientFactory = TestHelpers.CreateHttpClientFactory(); _bashCmdHandlerMock = new Mock <IBashCommandHandler>(MockBehavior.Strict); _managedIdentityTokenProvider = new Mock <IManagedIdentityTokenProvider>(MockBehavior.Strict); _logger = NullLogger <PackageDownloadHandler> .Instance; _metricsLogger = new TestMetricsLogger(); }
public static IHostBuilder ConfigureDefaultTestWebScriptHost(this IHostBuilder builder, Action <IWebJobsBuilder> configureWebJobs, Action <ScriptApplicationHostOptions> configure = null, bool runStartupHostedServices = false, Action <IServiceCollection> configureRootServices = null) { var webHostOptions = new ScriptApplicationHostOptions() { IsSelfHost = true, ScriptPath = TestHelpers.FunctionsTestDirectory, LogPath = TestHelpers.GetHostLogFileDirectory().FullName }; TestMetricsLogger metricsLogger = new TestMetricsLogger(); configure?.Invoke(webHostOptions); // Register root services var services = new ServiceCollection(); AddMockedSingleton <IDebugStateProvider>(services); AddMockedSingleton <IScriptHostManager>(services); AddMockedSingleton <IEnvironment>(services); AddMockedSingleton <IScriptWebHostEnvironment>(services); AddMockedSingleton <IEventGenerator>(services); AddMockedSingleton <IFunctionInvocationDispatcherFactory>(services); AddMockedSingleton <IHttpWorkerService>(services); AddMockedSingleton <IApplicationLifetime>(services); AddMockedSingleton <IDependencyValidator>(services); AddMockedSingleton <IAzureBlobStorageProvider>(services); services.AddSingleton <HostNameProvider>(); services.AddSingleton <IMetricsLogger>(metricsLogger); services.AddWebJobsScriptHostRouting(); services.AddLogging(); services.AddFunctionMetadataManager(webHostOptions, metricsLogger); configureRootServices?.Invoke(services); var rootProvider = new WebHostServiceProvider(services); builder .AddWebScriptHost(rootProvider, rootProvider, webHostOptions, configureWebJobs) .ConfigureAppConfiguration(c => { c.AddTestSettings(); }) .ConfigureServices(s => { s.AddScriptGrpc(); }); if (!runStartupHostedServices) { builder.ConfigureServices(s => s.RemoveAll <IHostedService>()); } webHostOptions.RootServiceProvider = rootProvider; return(builder); }
public void Log_WritesMetric_IgnoresOtherLogs() { var metrics = new TestMetricsLogger(); var logger = new UserLogMetricsLogger(LogCategories.CreateFunctionCategory(_functionName), metrics, _scopeProvider); // function executions will include this scope using (CreateFunctionScope(logger)) { logger.LogInformation("Message"); } Assert.Empty(metrics.LoggedEvents); }
public void ReadWorkerProviderFromConfig_EmptyWorkerPath() { var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, new string[0], false, string.Empty, true) }; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); Assert.Null(workerConfigs.Single().Description.DefaultWorkerPath); }
private IConfiguration BuildHostJsonConfiguration(TestMetricsLogger testMetricsLogger, IEnvironment environment = null) { environment = environment ?? new TestEnvironment(); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(_loggerProvider); var configSource = new HostJsonFileConfigurationSource(_options, environment, loggerFactory, testMetricsLogger); var configurationBuilder = new ConfigurationBuilder() .Add(configSource); return(configurationBuilder.Build()); }
public void Log_WritesMetric_ForUserLogs_WithoutFunctionName() { var metrics = new TestMetricsLogger(); var logger = new UserLogMetricsLogger(_functionCategory, metrics, _scopeProvider); // If for some reason the scope doesn't exist, we still want this to suceed, but // without a function name. logger.LogInformation("Message"); var expectedEvent = MetricsEventManager.GetAggregateKey(MetricEventNames.FunctionUserLog); string eventName = metrics.LoggedEvents.Single(); Assert.Equal(expectedEvent, eventName); }
public async Task ShutdownStandyChannels_WorkerRuntime_Node_Set() { var testMetricsLogger = new TestMetricsLogger(); _testEnvironment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, RpcWorkerConstants.NodeLanguageWorkerName); _rpcWorkerChannelManager = new WebHostRpcWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _rpcWorkerChannelFactory, _optionsMonitor, testMetricsLogger); IRpcWorkerChannel javaWorkerChannel = CreateTestChannel(RpcWorkerConstants.JavaLanguageWorkerName); _rpcWorkerChannelManager.ScheduleShutdownStandbyChannels(); Assert.True(AreRequiredMetricsEmitted(testMetricsLogger)); var initializedChannel = await _rpcWorkerChannelManager.GetChannelAsync(RpcWorkerConstants.JavaLanguageWorkerName); Assert.Null(initializedChannel); }
public RunFromPackageHandlerTests() { _environment = new TestEnvironment(); _meshServiceClientMock = new Mock <IMeshServiceClient>(MockBehavior.Strict); _bashCmdHandlerMock = new Mock <IBashCommandHandler>(MockBehavior.Strict); _zipHandler = new Mock <IUnZipHandler>(MockBehavior.Strict); _metricsLogger = new TestMetricsLogger(); _httpClient = new Mock <HttpClient>().Object; _logger = NullLogger <RunFromPackageHandler> .Instance; _runFromPackageHandler = new RunFromPackageHandler(_environment, _httpClient, _meshServiceClientMock.Object, _bashCmdHandlerMock.Object, _zipHandler.Object, _metricsLogger, _logger); }
public void MissingHostJson_CreatesDefaultFile() { Assert.False(File.Exists(_hostJsonFile)); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); BuildHostJsonConfiguration(testMetricsLogger); AreExpectedMetricsGenerated(testMetricsLogger); Assert.Equal(_defaultHostJson, File.ReadAllText(_hostJsonFile)); var log = _loggerProvider.GetAllLogMessages().Single(l => l.FormattedMessage == "No host configuration file found. Creating a default host.json file."); Assert.Equal(LogLevel.Information, log.Level); }
public void MissingVersion_ThrowsException() { string hostJsonContent = @" { 'functions': [ 'FunctionA', 'FunctionB' ] }"; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); File.WriteAllText(_hostJsonFile, hostJsonContent); Assert.True(File.Exists(_hostJsonFile)); var ex = Assert.Throws <HostConfigurationException>(() => BuildHostJsonConfiguration(testMetricsLogger)); Assert.StartsWith("The host.json file is missing the required 'version' property.", ex.Message); }
public void Log_WritesMetric_ForUserLogs() { var metrics = new TestMetricsLogger(); var logger = new UserLogMetricsLogger(_functionCategory, metrics, _scopeProvider); // function executions will include this scope using (CreateFunctionScope(logger)) { logger.LogInformation("Message"); } var expectedEvent = MetricsEventManager.GetAggregateKey(MetricEventNames.FunctionUserLog, _functionName); string eventName = metrics.LoggedEvents.Single(); Assert.Equal(expectedEvent, eventName); }
public async Task TestCounterEventPipeline() { var expectedCounters = new[] { "cpu-usage", "working-set" }; string expectedProvider = "System.Runtime"; IDictionary <string, IEnumerable <string> > expectedMap = new Dictionary <string, IEnumerable <string> >(); expectedMap.Add(expectedProvider, expectedCounters); var foundExpectedCountersSource = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); var logger = new TestMetricsLogger(expectedMap, foundExpectedCountersSource); await using (var testExecution = StartTraceeProcess("CounterRemoteTest")) { //TestRunner should account for start delay to make sure that the diagnostic pipe is available. var client = new DiagnosticsClient(testExecution.TestRunner.Pid); await using EventCounterPipeline pipeline = new EventCounterPipeline(client, new EventPipeCounterPipelineSettings { Duration = Timeout.InfiniteTimeSpan, CounterGroups = new[] { new EventPipeCounterGroup { ProviderName = expectedProvider, CounterNames = expectedCounters } }, CounterIntervalSeconds = 1 }, new[] { logger }); await PipelineTestUtilities.ExecutePipelineWithDebugee( _output, pipeline, testExecution, foundExpectedCountersSource); } Assert.True(logger.Metrics.Any()); var actualMetrics = logger.Metrics.Select(m => m.Name).OrderBy(m => m); Assert.Equal(expectedCounters, actualMetrics); Assert.True(logger.Metrics.All(m => string.Equals(m.Provider, expectedProvider))); }
public void ReadWorkerProviderFromConfig_ReturnsProviderNoArguments() { var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, new string[0]) }; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); Assert.Equal(Path.Combine(rootPath, testLanguage, $"{RpcWorkerConfigTestUtilities.TestWorkerPathInWorkerConfig}.{testLanguage}"), workerConfigs.Single().Description.DefaultWorkerPath); RpcWorkerConfig worker = workerConfigs.FirstOrDefault(); Assert.True(worker.Description.Arguments.Count == 0); }
public void ReadOnlyFileSystem_SkipsDefaultHostJsonCreation() { Assert.False(File.Exists(_hostJsonFile)); var environment = new TestEnvironment(new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsiteZipDeployment, "1" } }); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); IConfiguration config = BuildHostJsonConfiguration(testMetricsLogger, environment); AreExpectedMetricsGenerated(testMetricsLogger); Assert.Equal(config["AzureFunctionsJobHost:version"], "2.0"); var log = _loggerProvider.GetAllLogMessages().Single(l => l.FormattedMessage == "No host configuration file found. Creating a default host.json file."); Assert.Equal(LogLevel.Information, log.Level); }
public void InvalidVersionThrowsException(string versionLine, string errorStartsWith, string errorContains) { StringBuilder hostJsonContentBuilder = new StringBuilder(@"{"); hostJsonContentBuilder.Append(versionLine); hostJsonContentBuilder.Append(@"'functions': [ 'FunctionA', 'FunctionB' ]}"); string hostJsonContent = hostJsonContentBuilder.ToString(); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); File.WriteAllText(_hostJsonFile, hostJsonContent); Assert.True(File.Exists(_hostJsonFile)); var ex = Assert.Throws <HostConfigurationException>(() => BuildHostJsonConfiguration(testMetricsLogger)); Assert.StartsWith(errorStartsWith, ex.Message); Assert.Contains(errorContains, ex.Message); }
public void Initialize_Sanitizes_HostJsonLog() { // Turn off all logging. We shouldn't see any output. string hostJsonContent = @" { 'version': '2.0', 'functionTimeout': '00:05:00', 'functions': [ 'FunctionA', 'FunctionB' ], 'logging': { 'categoryFilter': { 'defaultLevel': 'Information' } }, 'Values': { 'MyCustomValue': 'abc' } }"; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); File.WriteAllText(_hostJsonFile, hostJsonContent); BuildHostJsonConfiguration(testMetricsLogger); AreExpectedMetricsGenerated(testMetricsLogger); string hostJsonSanitized = @" { 'version': '2.0', 'functionTimeout': '00:05:00', 'functions': [ 'FunctionA', 'FunctionB' ], 'logging': { 'categoryFilter': { 'defaultLevel': 'Information' } } }"; // for formatting var hostJson = JObject.Parse(hostJsonSanitized); var logger = _loggerProvider.CreatedLoggers.Single(l => l.Category == LogCategories.Startup); var logMessage = logger.GetLogMessages().Single(l => l.FormattedMessage.StartsWith("Host configuration file read")).FormattedMessage; Assert.Equal($"Host configuration file read:{Environment.NewLine}{hostJson}", logMessage); }
public void ReadWorkerProviderFromConfig_EmptyWorkerPath() { var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, new string[0], false, string.Empty, true) }; // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig Dictionary <string, string> keyValuePairs = new Dictionary <string, string> { [$"{RpcWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{WorkerConstants.WorkerDescriptionArguments}"] = "--inspect=5689 --no-deprecation" }; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); Assert.Null(workerConfigs.Single().Description.DefaultWorkerPath); }
public void ReadWorkerProviderFromConfig_ReturnsProviderWithArguments() { var expectedArguments = new string[] { "-v", "verbose" }; var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, expectedArguments) }; var testLogger = new TestLogger(testLanguage); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig IEnumerable <RpcWorkerConfig> workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger, testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); RpcWorkerConfig worker = workerConfigs.FirstOrDefault(); Assert.True(expectedArguments.SequenceEqual(worker.Description.Arguments.ToArray())); }
public void ReadWorkerProviderFromConfig_AddProfile_ReturnsDefaultDescription() { var expectedArguments = new string[] { "-v", "verbose" }; var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, expectedArguments, false, "TestProfile") }; var testLogger = new TestLogger(testLanguage); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig IEnumerable <RpcWorkerConfig> workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger, testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Single(workerConfigs); RpcWorkerConfig worker = workerConfigs.FirstOrDefault(); Assert.Equal(RpcWorkerConfigTestUtilities.TestDefaultExecutablePath, worker.Description.DefaultExecutablePath); }
public void ReadWorkerProviderFromConfig_InvalidWorker() { var testConfig = MakeTestConfig(testLanguage, new string[0]); var configs = new List <TestRpcWorkerConfig>() { testConfig }; TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); RpcWorkerConfigTestUtilities.CreateWorkerFolder(customRootPath, testConfig, false); Dictionary <string, string> keyValuePairs = new Dictionary <string, string> { [$"{RpcWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{WorkerConstants.WorkerDirectorySectionName}"] = customRootPath }; var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), testMetricsLogger, null, keyValuePairs); AreRequiredMetricsEmitted(testMetricsLogger); Assert.Empty(workerConfigs); }
public void ReadWorkerProviderFromConfig_InvalidConfigFile() { var configs = new List <TestRpcWorkerConfig>() { MakeTestConfig(testLanguage, new string[0], true) }; var testLogger = new TestLogger(testLanguage); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); // Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig var workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger, testMetricsLogger); AreRequiredMetricsEmitted(testMetricsLogger); var logs = testLogger.GetLogMessages(); var errorLog = logs.Where(log => log.Level == LogLevel.Error).FirstOrDefault(); Assert.NotNull(errorLog); Assert.NotNull(errorLog.Exception); Assert.True(errorLog.FormattedMessage.Contains("Failed to initialize")); Assert.Empty(workerConfigs); }
public void MissingHostJson_CreatesHostJson_withWorkFlowExtensionBundleId() { var environment = new TestEnvironment(new Dictionary <string, string> { { EnvironmentSettingNames.AppKind, "workflowApp" } }); Assert.False(File.Exists(_hostJsonFile)); TestMetricsLogger testMetricsLogger = new TestMetricsLogger(); BuildHostJsonConfiguration(testMetricsLogger, environment); AreExpectedMetricsGenerated(testMetricsLogger); Assert.Equal(_hostJsonWithWorkFlowBundle, File.ReadAllText(_hostJsonFile)); var log = _loggerProvider.GetAllLogMessages().Single(l => l.FormattedMessage == "No host configuration file found. Creating a default host.json file."); Assert.Equal(LogLevel.Information, log.Level); }
public void LogInvocationMetrics_EmitsExpectedEvents() { var metrics = new TestMetricsLogger(); Collection<BindingMetadata> bindings = new Collection<BindingMetadata> { new BindingMetadata { Type = "httpTrigger" }, new BindingMetadata { Type = "blob", Direction = BindingDirection.In }, new BindingMetadata { Type = "blob", Direction = BindingDirection.Out }, new BindingMetadata { Type = "table", Direction = BindingDirection.In }, new BindingMetadata { Type = "table", Direction = BindingDirection.In } }; FunctionInvokerBase.LogInvocationMetrics(metrics, bindings); Assert.Equal(6, metrics.LoggedEvents.Count); Assert.Equal("function.invoke", metrics.LoggedEvents[0]); Assert.Equal("function.binding.httpTrigger", metrics.LoggedEvents[1]); Assert.Equal("function.binding.blob.In", metrics.LoggedEvents[2]); Assert.Equal("function.binding.blob.Out", metrics.LoggedEvents[3]); Assert.Equal("function.binding.table.In", metrics.LoggedEvents[4]); Assert.Equal("function.binding.table.In", metrics.LoggedEvents[5]); }
public async Task GetFunctiontSecrets_AddsMetrics() { using (var directory = new TempDirectory()) { string functionName = "testfunction"; string expectedTraceMessage = string.Format(Resources.TraceNonDecryptedFunctionSecretRefresh, functionName); string functionSecretsJson = @"{ 'keys': [ { 'name': 'Key1', 'value': 'cryptoError', 'encrypted': true }, { 'name': 'Key2', 'value': '1234', 'encrypted': false } ] }"; File.WriteAllText(Path.Combine(directory.Path, functionName + ".json"), functionSecretsJson); Mock <IKeyValueConverterFactory> mockValueConverterFactory = GetConverterFactoryMock(true, false); IDictionary <string, string> functionSecrets; ISecretsRepository repository = new FileSystemSecretsRepository(directory.Path); TestMetricsLogger metricsLogger = new TestMetricsLogger(); using (var secretManager = new SecretManager(repository, mockValueConverterFactory.Object, null, metricsLogger)) { functionSecrets = await secretManager.GetFunctionSecretsAsync(functionName); } string eventName = string.Format(MetricEventNames.SecretManagerGetFunctionSecrets, repository.GetType().Name.ToLower()); metricsLogger.EventsBegan.Single(e => e.StartsWith(eventName)); metricsLogger.EventsBegan.Single(e => e.Contains("testfunction")); metricsLogger.EventsEnded.Single(e => e.ToString().StartsWith(eventName)); metricsLogger.EventsEnded.Single(e => e.ToString().Contains("testfunction")); } }