private static LanguageWorkerOptions GetTestLanguageWorkerOptions()
{
return(new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
});
}
public void ReadFunctionMetadata_With_Retry_Succeeds()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\noderetry");
_scriptApplicationHostOptions.ScriptPath = functionsPath;
var optionsMonitor = TestHelpers.CreateOptionsMonitor(_scriptApplicationHostOptions);
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, NullLogger <FunctionMetadataProvider> .Instance, _testMetricsLogger);
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
var functionMetadatas = metadataProvider.GetFunctionMetadata(workerConfigs, false);
Assert.Equal(2, functionMetadatas.Length);
var functionMetadataWithRetry = functionMetadatas.Where(f => f.Name.Contains("HttpTrigger-RetryFunctionJson", StringComparison.OrdinalIgnoreCase));
Assert.Single(functionMetadataWithRetry);
var retry = functionMetadataWithRetry.FirstOrDefault().Retry;
Assert.NotNull(retry);
Assert.Equal(RetryStrategy.FixedDelay, retry.Strategy);
Assert.Equal(4, retry.MaxRetryCount);
Assert.Equal(TimeSpan.Parse("00:00:03"), retry.DelayInterval);
var functionMetadata = functionMetadatas.Where(f => !f.Name.Contains("HttpTrigger-RetryFunctionJson", StringComparison.OrdinalIgnoreCase));
Assert.Single(functionMetadataWithRetry);
Assert.Null(functionMetadata.FirstOrDefault().Retry);
}
public void FunctionMetadataManager_IgnoresMetadata_FromFunctionProviders()
{
var functionMetadataCollection = new Collection <FunctionMetadata>();
var mockFunctionErrors = new Dictionary <string, ImmutableArray <string> >();
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false)).Returns(Task.FromResult(new Collection <FunctionMetadata>().ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
functionMetadataCollection.Add(GetTestFunctionMetadata("somefile.dll", name: "anotherFunction"));
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
mockFunctionProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors.ToImmutableDictionary());
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions),
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>()
{
mockFunctionProvider.Object
}, new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
Assert.Equal(0, testFunctionMetadataManager.GetFunctionMetadata(true, includeCustomProviders: false).Length);
Assert.Equal(0, testFunctionMetadataManager.Errors.Count);
}
public void FunctionMetadataManager_ThrowsError_DuplicateFunctions_FromFunctionProviders()
{
var functionMetadataCollection = new Collection <FunctionMetadata>();
var mockFunctionErrors = new Dictionary <string, ImmutableArray <string> >();
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var mockFunctionProviderDuplicate = new Mock <IFunctionProvider>();
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false)).Returns(Task.FromResult(new Collection <FunctionMetadata>().ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
functionMetadataCollection.Add(GetTestFunctionMetadata("somefile.dll", name: "duplicateFunction"));
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
mockFunctionProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors.ToImmutableDictionary());
mockFunctionProviderDuplicate.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
mockFunctionProviderDuplicate.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors.ToImmutableDictionary());
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions),
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>()
{
mockFunctionProvider.Object, mockFunctionProviderDuplicate.Object
},
new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(),
new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
var ex = Assert.Throws <InvalidOperationException>(() => testFunctionMetadataManager.LoadFunctionMetadata());
Assert.Equal("Found duplicate FunctionMetadata with the name duplicateFunction", ex.Message);
}
public object GetService(System.Type serviceType)
{
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
return(new FunctionMetadataProvider(_optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance));
}
public FunctionMetadataProviderTests()
{
_testMetricsLogger = new TestMetricsLogger();
_scriptApplicationHostOptions = new ScriptApplicationHostOptions();
_languageWorkerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
}
public void ReadFunctionMetadata_For_WorkerIndexingFormatApp_Fails()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..", "..", "..", "..", "..", "sample", "PythonWorkerIndexing");
_scriptApplicationHostOptions.ScriptPath = functionsPath;
var optionsMonitor = TestHelpers.CreateOptionsMonitor(_scriptApplicationHostOptions);
var metadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger <HostFunctionMetadataProvider> .Instance, _testMetricsLogger);
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
Assert.Equal(0, metadataProvider.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false).Result.Length);
}
public void ReadFunctionMetadata_Succeeds()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
_scriptApplicationHostOptions.ScriptPath = functionsPath;
var optionsMonitor = TestHelpers.CreateOptionsMonitor(_scriptApplicationHostOptions);
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, NullLogger <FunctionMetadataProvider> .Instance, _testMetricsLogger);
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
Assert.Equal(18, metadataProvider.GetFunctionMetadata(workerConfigs, false).Length);
Assert.True(AreRequiredMetricsEmitted(_testMetricsLogger));
}
public TestFixture()
{
// copy test files to temp directory, since accessing the metadata APIs will result
// in file creations (for test data files)
var scriptSource = Path.Combine(Environment.CurrentDirectory, "..", "..", "..", "TestScripts", "WarmupFunction");
_testHome = Path.Combine(Path.GetTempPath(), @"WarmupFunction");
var scriptRoot = Path.Combine(_testHome, "site", "wwwroot");
FileUtility.CopyDirectory(scriptSource, scriptRoot);
HostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = scriptRoot,
LogPath = Path.Combine(_testHome, "LogFiles", "Application", "Functions"),
SecretsPath = Path.Combine(_testHome, "data", "Functions", "Secrets"),
TestDataPath = Path.Combine(_testHome, "data", "Functions", "SampleData")
};
FileUtility.EnsureDirectoryExists(HostOptions.TestDataPath);
var optionsMonitor = TestHelpers.CreateOptionsMonitor(HostOptions);
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var provider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger <HostFunctionMetadataProvider> .Instance, new TestMetricsLogger());
var builder = AspNetCore.WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.ConfigureServices(services =>
{
services.Replace(new ServiceDescriptor(typeof(IOptions <ScriptApplicationHostOptions>), new OptionsWrapper <ScriptApplicationHostOptions>(HostOptions)));
services.Replace(new ServiceDescriptor(typeof(ISecretManagerProvider), new TestSecretManagerProvider(new TestSecretManager())));
services.Replace(new ServiceDescriptor(typeof(IOptionsMonitor <ScriptApplicationHostOptions>), optionsMonitor));
services.Replace(new ServiceDescriptor(typeof(IFunctionMetadataProvider), provider));
services.SkipDependencyValidation();
});
// TODO: https://github.com/Azure/azure-functions-host/issues/4876
_testServer = new TestServer(builder);
HostOptions.RootServiceProvider = _testServer.Host.Services;
var scriptConfig = _testServer.Host.Services.GetService <IOptions <ScriptJobHostOptions> >().Value;
HttpClient = _testServer.CreateClient();
HttpClient.BaseAddress = new Uri("https://localhost/");
TestHelpers.WaitForWebHost(HttpClient);
}
private FunctionMetadataManager GetMetadataManager(IOptionsMonitor <ScriptApplicationHostOptions> optionsMonitor, IScriptHostManager manager, ILoggerFactory factory)
{
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var managerServiceProvider = manager as IServiceProvider;
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, NullLogger <FunctionMetadataProvider> .Instance, new TestMetricsLogger());
var metadataManager = new FunctionMetadataManager(managerServiceProvider.GetService <IOptions <ScriptJobHostOptions> >(), metadataProvider,
managerServiceProvider.GetService <IOptions <HttpWorkerOptions> >(), manager, factory, new OptionsWrapper <LanguageWorkerOptions>(workerOptions));
return(metadataManager);
}
public void FunctionMetadataManager_ResetProviders_OnRefresh()
{
var functionMetadataCollection = new Collection <FunctionMetadata>();
var mockFunctionErrors = new Dictionary <string, ImmutableArray <string> >();
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false)).Returns(Task.FromResult(new Collection <FunctionMetadata>().ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
functionMetadataCollection.Add(GetTestFunctionMetadata("somefile.dll", name: "myFunction"));
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
mockFunctionProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors.ToImmutableDictionary());
var managerMock = new Mock <IScriptHostManager>();
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), managerMock,
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>()
{
mockFunctionProvider.Object
}, new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
testFunctionMetadataManager.LoadFunctionMetadata();
Assert.Equal(0, testFunctionMetadataManager.Errors.Count);
Assert.Equal(1, testFunctionMetadataManager.GetFunctionMetadata(true).Length);
Assert.Equal("myFunction", testFunctionMetadataManager.GetFunctionMetadata(true).FirstOrDefault()?.Name);
functionMetadataCollection = new Collection <FunctionMetadata>
{
GetTestFunctionMetadata("somefile.dll", name: "newFunction")
};
mockFunctionProvider = new Mock <IFunctionProvider>();
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
managerMock.As <IServiceProvider>().Setup(m => m.GetService(typeof(IEnumerable <IFunctionProvider>))).Returns(new List <IFunctionProvider>()
{
mockFunctionProvider.Object
});
testFunctionMetadataManager.LoadFunctionMetadata();
Assert.Equal(0, testFunctionMetadataManager.Errors.Count);
Assert.Equal(1, testFunctionMetadataManager.GetFunctionMetadata(true).Length);
Assert.Equal("newFunction", testFunctionMetadataManager.GetFunctionMetadata(true).FirstOrDefault()?.Name);
}
public void ReadFunctionMetadata_Succeeds()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
var scriptApplicationHostOptions = new ScriptApplicationHostOptions()
{
ScriptPath = functionsPath
};
var optionsMonitor = TestHelpers.CreateOptionsMonitor(scriptApplicationHostOptions);
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance);
Assert.Equal(17, metadataProvider.GetFunctionMetadata(false).Length);
}
public void GetFunctionMetadataAsync_InputMixedApp()
{
// Arrange
_logger.ClearLogMessages();
IEnumerable <RawFunctionMetadata> rawFunctionMetadataCollection = new List <RawFunctionMetadata>();
var functionMetadataCollection = new List <FunctionMetadata>();
functionMetadataCollection.Add(GetTestFunctionMetadata());
var workerConfigs = TestHelpers.GetTestWorkerConfigs().ToImmutableArray();
workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "true");
var scriptjobhostoptions = new ScriptJobHostOptions();
scriptjobhostoptions.RootScriptPath = Path.Combine(Environment.CurrentDirectory, @"..", "..", "..", "..", "..", "sample", "node");
var environment = SystemEnvironment.Instance;
environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "node");
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, "EnableWorkerIndexing");
_mockRpcFunctionInvocationDispatcher.Setup(m => m.InitializeAsync(functionMetadataCollection, default)).Returns(Task.FromResult(0));
_mockRpcFunctionInvocationDispatcher.Setup(m => m.GetWorkerMetadata()).Returns(Task.FromResult(rawFunctionMetadataCollection));
_aggregateFunctionMetadataProvider = new AggregateFunctionMetadataProvider(
_logger,
_mockRpcFunctionInvocationDispatcher.Object,
_mockFunctionMetadataProvider.Object,
new OptionsWrapper <ScriptJobHostOptions>(scriptjobhostoptions));
// Act
var functions = _aggregateFunctionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, environment, false).GetAwaiter().GetResult();
// Assert
string expectedLog = "Detected mixed function app. Some functions may not be indexed";
var traces = _logger.GetLogMessages();
Assert.False(traces.Where(m => m.FormattedMessage.Contains(expectedLog)).Any());
Task.Delay(TimeSpan.FromSeconds(65)).Wait();
traces = _logger.GetLogMessages();
Assert.True(traces.Where(m => m.FormattedMessage.Contains(expectedLog)).Any());
}
public void GetFunctionMetadataAsync_WorkerIndexing_HostFallback()
{
// Arrange
_logger.ClearLogMessages();
var function = GetTestRawFunctionMetadata(useDefaultMetadataIndexing: true);
IEnumerable <RawFunctionMetadata> rawFunctionMetadataCollection = new List <RawFunctionMetadata>()
{
function
};
var functionMetadataCollection = new List <FunctionMetadata>();
functionMetadataCollection.Add(GetTestFunctionMetadata());
var workerConfigs = TestHelpers.GetTestWorkerConfigs().ToImmutableArray();
workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "true");
var scriptjobhostoptions = new ScriptJobHostOptions();
scriptjobhostoptions.RootScriptPath = Path.Combine(Environment.CurrentDirectory, @"..", "..", "..", "..", "..", "sample", "node");
var environment = SystemEnvironment.Instance;
environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "node");
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, "EnableWorkerIndexing");
_mockRpcFunctionInvocationDispatcher.Setup(m => m.InitializeAsync(functionMetadataCollection, default)).Returns(Task.FromResult(0));
_mockRpcFunctionInvocationDispatcher.Setup(m => m.GetWorkerMetadata()).Returns(Task.FromResult(rawFunctionMetadataCollection));
_mockRpcFunctionInvocationDispatcher.Setup(m => m.FinishInitialization(functionMetadataCollection, default)).Returns(Task.FromResult(0));
_mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, environment, false)).Returns(Task.FromResult(functionMetadataCollection.ToImmutableArray()));
_aggregateFunctionMetadataProvider = new AggregateFunctionMetadataProvider(_logger, _mockRpcFunctionInvocationDispatcher.Object, _mockFunctionMetadataProvider.Object, new OptionsWrapper <ScriptJobHostOptions>(scriptjobhostoptions));
// Act
var functions = _aggregateFunctionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, environment, false).GetAwaiter().GetResult();
// Assert
var traces = _logger.GetLogMessages();
var functionLoadLogs = traces.Where(m => string.Equals(m.FormattedMessage, "Fallback to host indexing as worker denied indexing"));
Assert.True(functionLoadLogs.Any());
}
public void FunctionMetadataManager_Verify_FunctionErrors_FromFunctionProviders(string scriptFile)
{
var functionMetadataCollection = new Collection <FunctionMetadata>();
var mockFunctionErrors = new Dictionary <string, ImmutableArray <string> >();
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false)).Returns(Task.FromResult(new Collection <FunctionMetadata>().ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
functionMetadataCollection.Add(GetTestFunctionMetadata(scriptFile));
functionMetadataCollection.Add(GetTestFunctionMetadata(scriptFile, name: "anotherFunction"));
mockFunctionErrors["anotherFunction"] = new List <string>()
{
"error"
}.ToImmutableArray();
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
mockFunctionProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors.ToImmutableDictionary());
var managerMock = new Mock <IScriptHostManager>();
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), managerMock,
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>()
{
mockFunctionProvider.Object
}, new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
managerMock.Raise(m => m.HostInitializing += null, new EventArgs());
testFunctionMetadataManager.LoadFunctionMetadata();
Assert.Equal(2, testFunctionMetadataManager.Errors.Count);
ImmutableArray <string> functionErrors = testFunctionMetadataManager.Errors["anotherFunction"];
Assert.Equal(2, functionErrors.Length);
Assert.True(functionErrors.Contains("error"));
}
public void FunctionMetadataManager_SortsMetadata_FromFunctionProviders()
{
var functionMetadataCollection = new Collection <FunctionMetadata>();
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var workerConfigs = TestHelpers.GetTestWorkerConfigs();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, false)).Returns(Task.FromResult(new Collection <FunctionMetadata>().ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
const string aFunction = "aFunction";
const string bFunction = "bFunction";
const string cFunction = "cFunction";
// Add in unsorted order
functionMetadataCollection.Add(GetTestFunctionMetadata("b.dll", name: bFunction));
functionMetadataCollection.Add(GetTestFunctionMetadata("a.dll", name: aFunction));
functionMetadataCollection.Add(GetTestFunctionMetadata("c.dll", name: cFunction));
functionMetadataCollection.Add(GetTestFunctionMetadata("null.dll", name: null));
mockFunctionProvider.Setup(m => m.GetFunctionMetadataAsync()).ReturnsAsync(functionMetadataCollection.ToImmutableArray());
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions),
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>()
{
mockFunctionProvider.Object
}, new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
var functionMetadata = testFunctionMetadataManager.LoadFunctionMetadata();
Assert.Equal(4, functionMetadata.Length);
Assert.Null(functionMetadata[0].Name);
Assert.True(string.Equals(aFunction, functionMetadata[1].Name));
Assert.True(string.Equals(bFunction, functionMetadata[2].Name));
Assert.True(string.Equals(cFunction, functionMetadata[3].Name));
}
public void ParseLanguage_Returns_ExpectedLanguage(string language, string scriptFile, bool includeDllWorker)
{
Assert.Equal(language, FunctionMetadataProvider.ParseLanguage(scriptFile, TestHelpers.GetTestWorkerConfigs(includeDllWorker: includeDllWorker)));
}
public void ParseLanguage_Returns_ExpectedLanguage(string language, string scriptFile)
{
Assert.Equal(language, FunctionMetadataManager.ParseLanguage(scriptFile, TestHelpers.GetTestWorkerConfigs()));
}
public void ReadFunctionMetadata_Succeeds()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
var functionErrors = new Dictionary <string, ICollection <string> >();
var functionDirectories = Directory.EnumerateDirectories(functionsPath);
var metadata = FunctionMetadataManager.ReadFunctionsMetadata(functionDirectories, null, TestHelpers.GetTestWorkerConfigs(), NullLogger.Instance, functionErrors);
Assert.Equal(17, metadata.Count);
}
