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