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 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 static FunctionMetadata GetFunctionMetadata(string functionName)
{
var functionErrors = new Dictionary <string, Collection <string> >();
var scriptHostOptions = new ScriptJobHostOptions
{
RootScriptPath = Environment.CurrentDirectory
};
var loggerFactory = new LoggerFactory();
var languageWorkerOptions = new LanguageWorkerOptions {
};
loggerFactory.AddProvider(new ColoredConsoleLoggerProvider((cat, level) => level >= LogLevel.Information));
var metadataManager = new FunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(scriptHostOptions), new OptionsWrapper <LanguageWorkerOptions>(languageWorkerOptions), loggerFactory);
var function = metadataManager.Functions.FirstOrDefault(f => f.Name.Equals(functionName, StringComparison.OrdinalIgnoreCase));
if (function == null)
{
var error = metadataManager.Errors
.FirstOrDefault(f => f.Key.Equals(functionName, StringComparison.OrdinalIgnoreCase))
.Value
.Aggregate(string.Empty, (a, b) => string.Join(Environment.NewLine, a, b));
throw new FunctionNotFoundException($"Unable to get metadata for function {functionName}. Error: {error}");
}
else
{
return(function);
}
}
public void FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
{
Collection <FunctionMetadata> functionMetadataCollection = new Collection <FunctionMetadata>();
functionMetadataCollection.Add(GetTestFunctionMetadata(scriptFile));
ImmutableDictionary <string, ImmutableArray <string> > mockFunctionErrors = new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());
Mock <IFunctionMetadataProvider> mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(It.IsAny <IEnumerable <RpcWorkerConfig> >(), SystemEnvironment.Instance, false)).Returns(Task.FromResult(functionMetadataCollection.ToImmutableArray()));
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors);
var managerMock = new Mock <IScriptHostManager>();
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), managerMock,
mockFunctionMetadataProvider.Object, new List <IFunctionProvider>(), new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
managerMock.Raise(m => m.HostInitializing += null, new EventArgs());
Assert.Empty(testFunctionMetadataManager.LoadFunctionMetadata());
Assert.True(testFunctionMetadataManager.Errors.Count == 1);
ImmutableArray <string> functionErrors = testFunctionMetadataManager.Errors["testFunction"];
Assert.True(functionErrors.Length == 1);
Assert.Equal(_expectedErrorMessage, functionErrors[0]);
}
public void IsScriptFileDetermined_ScriptFile_Emtpy_HttpWorker_Returns_True(string scriptFile)
{
FunctionMetadata functionMetadata = GetTestFunctionMetadata(scriptFile);
FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper <LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper <HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory());
Assert.True(testFunctionMetadataManager.IsScriptFileDetermined(functionMetadata));
}
public void ValidateFunctionName_ThrowsOnInvalidName(string functionName)
{
var ex = Assert.Throws <InvalidOperationException>(() =>
{
FunctionMetadataManager.ValidateName(functionName);
});
Assert.Equal(string.Format("'{0}' is not a valid function name.", functionName), ex.Message);
}
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);
}
public FunctionMetadataManagerTests()
{
_mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
_defaultHttpWorkerOptions = new HttpWorkerOptions();
_scriptJobHostOptions.RootScriptPath = functionsPath;
_testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper <LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
}
public void DeterminePrimaryScriptFile_NoFiles_ReturnsNull()
{
var functionConfig = new JObject();
string[] functionFiles = new string[0];
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\functions");
Assert.Throws <FunctionConfigurationException>(() => FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem));
}
public void ValidateFunctionName_DoesNotThrowOnValidName(string functionName)
{
try
{
FunctionMetadataManager.ValidateName(functionName);
}
catch (InvalidOperationException)
{
Assert.True(false, $"Valid function name {functionName} failed validation.");
}
}
public void DeterminePrimaryScriptFile_SingleFile()
{
var functionConfig = new JObject();
var files = new Dictionary <string, MockFileData>
{
{ @"c:\functions\Run.csx", new MockFileData(string.Empty) }
};
var fileSystem = new MockFileSystem(files);
string scriptFile = FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem);
Assert.Equal(@"c:\functions\Run.csx", scriptFile);
}
public void IsScriptFileDetermined_ScriptFile_Emtpy_HttpWorker_Returns_True(string scriptFile)
{
FunctionMetadata functionMetadata = GetTestFunctionMetadata(scriptFile);
var managerMock = new Mock <IScriptHostManager>();
FunctionMetadataManager testFunctionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), managerMock,
_mockFunctionMetadataProvider.Object, new List <IFunctionProvider>(), new OptionsWrapper <HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory(), new OptionsWrapper <LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
managerMock.Raise(m => m.HostInitializing += null, new EventArgs());
Assert.True(testFunctionMetadataManager.IsScriptFileDetermined(functionMetadata));
}
public void DeterminePrimaryScriptFile_MultipleFiles_IndexFilePresent()
{
var functionConfig = new JObject();
var files = new Dictionary <string, MockFileData>
{
{ @"c:\functions\index.js", new MockFileData(string.Empty) },
{ @"c:\functions\test.txt", new MockFileData(string.Empty) }
};
var fileSystem = new MockFileSystem(files);
string scriptFile = FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem);
Assert.Equal(@"c:\functions\index.js", scriptFile);
}
public void DeterminePrimaryScriptFile_MultipleFiles_NoClearPrimary_ReturnsNull()
{
var functionConfig = new JObject();
var files = new Dictionary <string, MockFileData>
{
{ @"c:\functions\foo.py", new MockFileData(string.Empty) },
{ @"c:\functions\queueTrigger.py", new MockFileData(string.Empty) },
{ @"c:\functions\helper.py", new MockFileData(string.Empty) },
{ @"c:\functions\test.txt", new MockFileData(string.Empty) }
};
var fileSystem = new MockFileSystem(files);
Assert.Throws <FunctionConfigurationException>(() => FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem));
}
/// <summary>
/// maps a functionName to its FunctionMetadataResponse
/// </summary>
/// <param name="name">Function name to retrieve</param>
/// <param name="request">Current HttpRequest</param>
/// <returns>(success, FunctionMetadataResponse)</returns>
public async Task <(bool, FunctionMetadataResponse)> TryGetFunction(string name, HttpRequest request, IWebJobsRouter router = null)
{
// TODO: DI (FACAVAL) Follow up with ahmels - Since loading of function metadata is no longer tied to the script host, we
// should be able to inject an IFunctionMedatadaManager here and bypass this step.
var functionMetadata = FunctionMetadataManager.ReadFunctionMetadata(Path.Combine(_config.RootScriptPath, name), null, _workerConfigs, new Dictionary <string, ICollection <string> >(), fileSystem: FileUtility.Instance);
if (functionMetadata != null)
{
return(true, await functionMetadata.ToFunctionMetadataResponse(request, _config, router));
}
else
{
return(false, null);
}
}
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 InitializesEmptyOrMissingDirectorySnapshot(string rootScriptPath)
{
var scriptConfig = new ScriptJobHostOptions()
{
RootScriptPath = rootScriptPath
};
IOptions <ScriptJobHostOptions> scriptOptions = new OptionsManager <ScriptJobHostOptions>(new TestOptionsFactory <ScriptJobHostOptions>(scriptConfig));
IOptions <LanguageWorkerOptions> languageWorkerOptions = new OptionsManager <LanguageWorkerOptions>(new TestOptionsFactory <LanguageWorkerOptions>(new LanguageWorkerOptions()));
var functionMetadataManager = new FunctionMetadataManager(scriptOptions, languageWorkerOptions, NullLoggerFactory.Instance);
Assert.False(functionMetadataManager.Functions.IsDefault);
Assert.True(functionMetadataManager.Functions.IsEmpty);
}
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);
}
/// <summary>
/// maps a functionName to its FunctionMetadataResponse
/// </summary>
/// <param name="name">Function name to retrieve</param>
/// <param name="request">Current HttpRequest</param>
/// <returns>(success, FunctionMetadataResponse)</returns>
public async Task <(bool, FunctionMetadataResponse)> TryGetFunction(string name, HttpRequest request)
{
// TODO: DI (FACAVAL) Follow up with ahmels - Since loading of function metadata is no longer tied to the script host, we
// should be able to inject an IFunctionMetadataManager here and bypass this step.
var hostOptions = _applicationHostOptions.CurrentValue.ToHostOptions();
var functionMetadata = FunctionMetadataManager.ReadFunctionMetadata(Path.Combine(hostOptions.RootScriptPath, name), null, _workerConfigs, new Dictionary <string, ICollection <string> >(), fileSystem: FileUtility.Instance);
if (functionMetadata != null)
{
string routePrefix = await GetRoutePrefix(hostOptions.RootScriptPath);
return(true, await functionMetadata.ToFunctionMetadataResponse(request, hostOptions, routePrefix));
}
else
{
return(false, null);
}
}
internal IEnumerable <FunctionMetadata> GetFunctionsMetadata(bool includeProxies = false)
{
// get functions metadata
var functionDirectories = FileUtility.EnumerateDirectories(_hostOptions.RootScriptPath);
IEnumerable <FunctionMetadata> functionsMetadata = FunctionMetadataManager.ReadFunctionsMetadata(functionDirectories, null, _workerConfigs, _logger, fileSystem: FileUtility.Instance);
if (includeProxies)
{
// get proxies metadata
var proxyMetadata = _proxyMetadataManager.ProxyMetadata;
if (!proxyMetadata.Functions.IsDefaultOrEmpty)
{
functionsMetadata = proxyMetadata.Functions.Concat(functionsMetadata);
}
}
return(functionsMetadata);
}
internal static IEnumerable <FunctionMetadata> GetFunctionsMetadata(ScriptJobHostOptions hostOptions, IEnumerable <WorkerConfig> workerConfigs, ILogger logger, bool includeProxies = false)
{
var functionDirectories = FileUtility.EnumerateDirectories(hostOptions.RootScriptPath);
IEnumerable <FunctionMetadata> functionsMetadata = FunctionMetadataManager.ReadFunctionsMetadata(functionDirectories, null, workerConfigs, logger, fileSystem: FileUtility.Instance);
if (includeProxies)
{
// get proxies metadata
var values = ProxyMetadataManager.ReadProxyMetadata(hostOptions.RootScriptPath, logger);
var proxyFunctionsMetadata = values.Item1;
if (proxyFunctionsMetadata?.Count > 0)
{
functionsMetadata = proxyFunctionsMetadata.Concat(functionsMetadata);
}
}
return(functionsMetadata);
}
internal IEnumerable <FunctionMetadata> GetFunctionsMetadata(bool includeProxies = false)
{
var hostOptions = _applicationHostOptions.CurrentValue.ToHostOptions();
var functionDirectories = FileUtility.EnumerateDirectories(hostOptions.RootScriptPath);
IEnumerable <FunctionMetadata> functionsMetadata = FunctionMetadataManager.ReadFunctionsMetadata(functionDirectories, null, _workerConfigs, _logger, fileSystem: FileUtility.Instance);
if (includeProxies)
{
// get proxies metadata
var values = ProxyMetadataManager.ReadProxyMetadata(hostOptions.RootScriptPath, _logger);
var proxyFunctionsMetadata = values.Item1;
if (proxyFunctionsMetadata?.Count > 0)
{
functionsMetadata = proxyFunctionsMetadata.Concat(functionsMetadata);
}
}
return(functionsMetadata);
}
public void DeterminePrimaryScriptFile_MultipleFiles_ConfigTrumpsConvention()
{
JObject functionConfig = new JObject()
{
{ "scriptFile", "queueTrigger.py" }
};
var files = new Dictionary <string, MockFileData>
{
{ @"c:\functions\run.py", new MockFileData(string.Empty) },
{ @"c:\functions\queueTrigger.py", new MockFileData(string.Empty) },
{ @"c:\functions\helper.py", new MockFileData(string.Empty) },
{ @"c:\functions\test.txt", new MockFileData(string.Empty) }
};
var fileSystem = new MockFileSystem(files);
string scriptFile = FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem);
Assert.Equal(@"c:\functions\queueTrigger.py", scriptFile);
}
public void DeterminePrimaryScriptFile_MultipleFiles_SourceFileSpecified(string scriptFileName)
{
JObject functionConfig = new JObject()
{
{ "scriptFile", scriptFileName }
};
var files = new Dictionary <string, MockFileData>
{
{ @"c:\functions\queueTrigger.py", new MockFileData(string.Empty) },
{ @"c:\functions\helper.py", new MockFileData(string.Empty) },
{ @"c:\functions\test.txt", new MockFileData(string.Empty) }
};
var fileSystem = new MockFileSystem(files);
string scriptFile = FunctionMetadataManager.DeterminePrimaryScriptFile(functionConfig, @"c:\functions", fileSystem);
Assert.Equal(@"c:\functions\queueTrigger.py", scriptFile, StringComparer.OrdinalIgnoreCase);
}
public void FunctionMetadataManager_DoesNotError_MissingScriptFile_InWebHostMode()
{
var mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
var mockFunctionProvider = new Mock <IFunctionProvider>();
var testMetadata = GetTestFunctionMetadata(null);
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()));
Assert.True(testFunctionMetadataManager.IsScriptFileDetermined(testMetadata));
managerMock.Raise(m => m.HostInitializing += null, new EventArgs());
Assert.False(testFunctionMetadataManager.IsScriptFileDetermined(testMetadata));
}
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 FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
{
Collection <FunctionMetadata> functionMetadataCollection = new Collection <FunctionMetadata>();
functionMetadataCollection.Add(GetTestFunctionMetadata(scriptFile));
ImmutableDictionary <string, ImmutableArray <string> > mockFunctionErrors = new Dictionary <string, ICollection <string> >().ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());
Mock <IFunctionMetadataProvider> mockFunctionMetadataProvider = new Mock <IFunctionMetadataProvider>();
mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadata(false)).Returns(functionMetadataCollection.ToImmutableArray());
mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors);
FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(_scriptJobHostOptions), mockFunctionMetadataProvider.Object, new OptionsWrapper <LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper <HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
var validatedFunctionMetadataArray = testFunctionMetadataManager.LoadFunctionMetadata();
Assert.Empty(validatedFunctionMetadataArray);
Assert.True(testFunctionMetadataManager.Errors.Count == 1);
ImmutableArray <string> functionErrors = testFunctionMetadataManager.Errors["testFunction"];
Assert.True(functionErrors.Length == 1);
Assert.Equal(_expectedErrorMessage, functionErrors[0]);
}
public void ParseLanguage_Returns_ExpectedLanguage(string language, string scriptFile)
{
Assert.Equal(language, FunctionMetadataManager.ParseLanguage(scriptFile, TestHelpers.GetTestWorkerConfigs()));
}
internal IEnumerable <FunctionMetadata> GetFunctionsMetadata()
{
return(FunctionMetadataManager
.ReadFunctionsMetadata(FileUtility.EnumerateDirectories(_config.RootScriptPath), null, _workerConfigs, _logger, fileSystem: FileUtility.Instance));
}
