Throw error if there are no functions matching the language set by the runtime (#3599)

* Update IsSingleLanguage to return false if there are no functions matching the FUNCTIONS_RUNTIME_WORKER

* Update exception message

* Addressing comments

* Adding exception case to check if functions are dotnet

* Fixing null argument tests

* Warning user rather than throwing

* Throwing argument null exception

* Argument name for null exception

* Using nameof to get argument name

* Fixing typo

Author: pragnagopa

src/WebJobs.Script/Host/ScriptHost.cs

@@ -714,9 +714,16 @@ internal async Task<Collection<FunctionDescriptor>> GetFunctionDescriptorsAsync(
             Collection<FunctionDescriptor> functionDescriptors = new Collection<FunctionDescriptor>();
             var httpFunctions = new Dictionary<string, HttpTriggerAttribute>();
 
-            if (!_scriptHostEnvironment.IsDevelopment() && !Utility.IsSingleLanguage(functions, _currentRuntimeLanguage))
+            if (!Utility.IsSingleLanguage(functions, _currentRuntimeLanguage))
             {
-                throw new HostInitializationException($"Found functions with more than one language. Select a language for your function app by specifying {LanguageWorkerConstants.FunctionWorkerRuntimeSettingName} AppSetting");
+                if (string.IsNullOrEmpty(_currentRuntimeLanguage))
+                {
+                    _logger.LogWarning($"Select a language for your function app by specifying {LanguageWorkerConstants.FunctionWorkerRuntimeSettingName} AppSetting");
+                }
+                else
+                {
+                    _logger.LogWarning($"Did not find functions with language [{_currentRuntimeLanguage}].");
+                }
             }
 
             foreach (FunctionMetadata metadata in functions)

src/WebJobs.Script/Utility.cs

@@ -439,17 +439,22 @@ internal static bool TryReadFunctionConfig(string scriptDir, out string json, IF
             return true;
         }
 
-        internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string language)
+        internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)
         {
-            if (string.IsNullOrEmpty(language))
+            if (functions == null)
             {
-                if (functions != null && functions.Any())
-                {
-                    var functionsListWithoutProxies = functions.Where(f => f.IsProxy == false);
-                    return functionsListWithoutProxies.Select(f => f.Language).Distinct().Count() <= 1;
-                }
+                throw new ArgumentNullException(nameof(functions));
             }
-            return true;
+            var functionsListWithoutProxies = functions.Where(f => f.IsProxy == false).ToArray();
+            if (functionsListWithoutProxies.Length == 0)
+            {
+                return true;
+            }
+            if (string.IsNullOrEmpty(currentRuntimeLanguage))
+            {
+                return functionsListWithoutProxies.Select(f => f.Language).Distinct().Count() <= 1;
+            }
+            return ContainsFunctionWithCurrentLanguage(functionsListWithoutProxies, currentRuntimeLanguage);
         }
 
         internal static bool ShouldInitiliazeLanguageWorkers(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)
@@ -477,6 +482,10 @@ private static bool ContainsNonDotNetFunctions(IEnumerable<FunctionMetadata> fun
 
         private static bool ContainsFunctionWithCurrentLanguage(IEnumerable<FunctionMetadata> functions, string currentLanguage)
         {
+            if (string.Equals(currentLanguage, LanguageWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase))
+            {
+                return functions.Any(f => dotNetLanguages.Any(l => l.Equals(f.Language, StringComparison.OrdinalIgnoreCase)));
+            }
             if (functions != null && functions.Any())
             {
                 return functions.Any(f => f.Language.Equals(currentLanguage, StringComparison.OrdinalIgnoreCase));

test/WebJobs.Script.Tests/ScriptHostTests.cs

@@ -781,7 +781,47 @@ public void IsSingleLanguage_Returns_True_Proxy()
         }
 
         [Fact]
-        public void IsSingleLanguage_FunctionsWorkerRuntime_Set_Returns_True_()
+        public void IsSingleLanguage_Returns_True_OnlyProxies()
+        {
+            FunctionMetadata proxy1 = new FunctionMetadata()
+            {
+                Name = "proxy",
+                IsProxy = true
+            };
+            FunctionMetadata proxy2 = new FunctionMetadata()
+            {
+                Name = "proxy",
+                IsProxy = true
+            };
+            IEnumerable<FunctionMetadata> functionsList = new Collection<FunctionMetadata>()
+            {
+                proxy1, proxy2
+            };
+            Assert.True(Utility.IsSingleLanguage(functionsList, null));
+        }
+
+        [Fact]
+        public void IsSingleLanguage_FunctionsWorkerRuntime_Set_Returns_True_OnlyProxies()
+        {
+            FunctionMetadata proxy1 = new FunctionMetadata()
+            {
+                Name = "proxy",
+                IsProxy = true
+            };
+            FunctionMetadata proxy2 = new FunctionMetadata()
+            {
+                Name = "proxy",
+                IsProxy = true
+            };
+            IEnumerable<FunctionMetadata> functionsList = new Collection<FunctionMetadata>()
+            {
+                proxy1, proxy2
+            };
+            Assert.True(Utility.IsSingleLanguage(functionsList, "python"));
+        }
+
+        [Fact]
+        public void IsSingleLanguage_FunctionsWorkerRuntime_Set_Returns_True()
         {
             FunctionMetadata funcPython1 = new FunctionMetadata()
             {
@@ -805,6 +845,26 @@ public void IsSingleLanguage_FunctionsWorkerRuntime_Set_Returns_True_()
             Assert.True(Utility.IsSingleLanguage(functionsList, "node"));
         }
 
+        [Fact]
+        public void IsSingleLanguage_FunctionsWorkerRuntime_Set_Returns_False()
+        {
+            FunctionMetadata funcPython1 = new FunctionMetadata()
+            {
+                Name = "funcPython1",
+                Language = "python",
+            };
+            FunctionMetadata funcCSharp1 = new FunctionMetadata()
+            {
+                Name = "funcCSharp1",
+                Language = "CSharp",
+            };
+            IEnumerable<FunctionMetadata> functionsList = new Collection<FunctionMetadata>()
+            {
+                funcPython1, funcCSharp1
+            };
+            Assert.False(Utility.IsSingleLanguage(functionsList, "node"));
+        }
+
         [Fact]
         public void IsSingleLanguage_Returns_False()
         {
@@ -826,9 +886,15 @@ public void IsSingleLanguage_Returns_False()
         }
 
         [Fact]
-        public void IsSingleLanguage_FunctionsList_Null_Returns_False()
+        public void IsSingleLanguage_FunctionsList_Null_FunctionsWorkerRuntime_Throws_ArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => Utility.IsSingleLanguage(null, "dotnet"));
+        }
+
+        [Fact]
+        public void IsSingleLanguage_FunctionsList_Null_Throws_ArgumentNullException()
         {
-            Assert.True(Utility.IsSingleLanguage(null, null));
+            Assert.Throws<ArgumentNullException>(() => Utility.IsSingleLanguage(null, null));
         }
 
         [Fact]