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