Exclude test data from functions endpoint response (#10943)

kshyju · web-flow · commit 8e8c1cee9273 · 2025-03-28T16:22:08.000-07:00
* Exclude test data from functions endpoint response.

* Rename feature flag to be more generic (for READ and WRITE). Update write code path to check feature flag.

* reset FileUtility.Instance after test

* fix Property_ValidateAccess test

* Adding a test for the write code path of the test data file.

* PR feedbak updates.
- Switched from `IOptions&lt;FunctionsHostingConfigOptions&gt;` to `IOptionsMonitor&lt;FunctionsHostingConfigOptions&gt;`
- renamed feature flag.
diff --git a/release_notes.md b/release_notes.md
@@ -13,6 +13,7 @@
 - Fixing invalid DateTimes in status blobs when invoking via portal (#10916)
 - Bug fix for platform release channel bundles resolution casing issue and additional logging (#10921)
 - Adding support for faas.invoke_duration metric and other spec related updates (#10929)
+- Added the option to exclude test data from the `/functions` endpoint API response (#10943)
 - Increased the GC allocation budget value to improve cold start (#10953)
 - Fixed bug that could result in "Binding names must be unique" error (#10938)
 - Fix race condition that leads the host to initialize placeholder (warmup) function in Linux environments (#10848)
diff --git a/src/WebJobs.Script.WebHost/Extensions/FunctionMetadataExtensions.cs b/src/WebJobs.Script.WebHost/Extensions/FunctionMetadataExtensions.cs
@@ -19,8 +19,9 @@ public static class FunctionMetadataExtensions
         /// </summary>
         /// <param name="functionMetadata">FunctionMetadata to be mapped.</param>
         /// <param name="hostOptions">The host options.</param>
+        /// <param name="excludeTestData">If true, the returned <see cref="FunctionMetadataResponse"/> will not populate the <see cref="FunctionMetadataResponse.TestData"/> property.</param>
         /// <returns>Promise of a FunctionMetadataResponse.</returns>
-        public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, string routePrefix, string baseUrl)
+        public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, string routePrefix, string baseUrl, bool excludeTestData)
         {
             string functionPath = GetFunctionPathOrNull(hostOptions.RootScriptPath, functionMetadata.Name);
             string functionMetadataFilePath = GetMetadataPathOrNull(functionPath);
@@ -54,7 +55,7 @@ public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(th
                 response.ConfigHref = VirtualFileSystem.FilePathToVfsUri(functionMetadataFilePath, baseUrl, hostOptions);
             }
 
-            if (!string.IsNullOrEmpty(hostOptions.TestDataPath))
+            if (!excludeTestData && !string.IsNullOrEmpty(hostOptions.TestDataPath))
             {
                 var testDataFilePath = functionMetadata.GetTestDataFilePath(hostOptions);
                 response.TestDataHref = VirtualFileSystem.FilePathToVfsUri(testDataFilePath, baseUrl, hostOptions);
@@ -194,7 +195,7 @@ private static JObject GetFunctionConfigFromMetadata(FunctionMetadata metadata)
 
         private static async Task<string> GetTestData(string testDataPath, ScriptJobHostOptions config)
         {
-            if (!File.Exists(testDataPath))
+            if (!FileUtility.FileExists(testDataPath))
             {
                 FileUtility.EnsureDirectoryExists(Path.GetDirectoryName(testDataPath));
                 await FileUtility.WriteAsync(testDataPath, string.Empty);
diff --git a/src/WebJobs.Script.WebHost/Management/FunctionsSyncManager.cs b/src/WebJobs.Script.WebHost/Management/FunctionsSyncManager.cs
@@ -339,7 +339,7 @@ private async Task<SyncTriggersPayload> GetSyncTriggersPayload()
 
             // Add all listable functions details to the payload
             var listableFunctions = _functionMetadataManager.GetFunctionMetadata().Where(m => !m.IsCodeless());
-            var functionDetails = await WebFunctionsManager.GetFunctionMetadataResponse(listableFunctions, hostOptions, _hostNameProvider);
+            var functionDetails = await WebFunctionsManager.GetFunctionMetadataResponse(listableFunctions, hostOptions, _hostNameProvider, excludeTestData: _hostingConfigOptions.Value.IsTestDataSuppressionEnabled);
             result.Add("functions", new JArray(functionDetails.Select(p => JObject.FromObject(p))));
 
             // TEMP: refactor this code to properly add extensions in all scenario(#7394)
diff --git a/src/WebJobs.Script.WebHost/Management/WebFunctionsManager.cs b/src/WebJobs.Script.WebHost/Management/WebFunctionsManager.cs
@@ -7,14 +7,12 @@
 using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
-using Azure;
-using Azure.Core;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Management.Models;
 using Microsoft.Azure.WebJobs.Script.WebHost.Extensions;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
@@ -33,9 +31,10 @@ public class WebFunctionsManager : IWebFunctionsManager
         private readonly IFunctionMetadataManager _functionMetadataManager;
         private readonly IHostFunctionMetadataProvider _hostFunctionMetadataProvider;
         private readonly IOptionsMonitor<LanguageWorkerOptions> _languageWorkerOptions;
+        private readonly IOptionsMonitor<FunctionsHostingConfigOptions> _hostingConfigOptions;
 
         public WebFunctionsManager(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, ILoggerFactory loggerFactory, IHttpClientFactory httpClientFactory, ISecretManagerProvider secretManagerProvider, IFunctionsSyncManager functionsSyncManager, HostNameProvider hostNameProvider, IFunctionMetadataManager functionMetadataManager, IHostFunctionMetadataProvider hostFunctionMetadataProvider,
-            IOptionsMonitor<LanguageWorkerOptions> languageWorkerOptions)
+            IOptionsMonitor<LanguageWorkerOptions> languageWorkerOptions, IOptionsMonitor<FunctionsHostingConfigOptions> hostingConfigOptions)
         {
             _applicationHostOptions = applicationHostOptions;
             _logger = loggerFactory?.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
@@ -46,21 +45,22 @@ public WebFunctionsManager(IOptionsMonitor<ScriptApplicationHostOptions> applica
             _functionMetadataManager = functionMetadataManager;
             _hostFunctionMetadataProvider = hostFunctionMetadataProvider;
             _languageWorkerOptions = languageWorkerOptions;
+            _hostingConfigOptions = hostingConfigOptions;
         }
 
         public async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionsMetadata(bool includeProxies)
         {
             var hostOptions = _applicationHostOptions.CurrentValue.ToHostOptions();
             var functionsMetadata = GetFunctionsMetadata(includeProxies, forceRefresh: false);
 
-            return await GetFunctionMetadataResponse(functionsMetadata, hostOptions, _hostNameProvider);
+            return await GetFunctionMetadataResponse(functionsMetadata, hostOptions, _hostNameProvider, excludeTestData: _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);
         }
 
-        internal static async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionMetadataResponse(IEnumerable<FunctionMetadata> functionsMetadata, ScriptJobHostOptions hostOptions, HostNameProvider hostNameProvider)
+        internal static async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionMetadataResponse(IEnumerable<FunctionMetadata> functionsMetadata, ScriptJobHostOptions hostOptions, HostNameProvider hostNameProvider, bool excludeTestData)
         {
             string baseUrl = GetBaseUrl(hostNameProvider);
             string routePrefix = await GetRoutePrefix(hostOptions.RootScriptPath);
-            var tasks = functionsMetadata.Select(p => p.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl));
+            var tasks = functionsMetadata.Select(p => p.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl, excludeTestData));
 
             return await tasks.WhenAll();
         }
@@ -148,7 +148,7 @@ await functionMetadata
                 configChanged = true;
             }
 
-            if (functionMetadata.TestData != null)
+            if (functionMetadata.TestData != null && !_hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled)
             {
                 await FileUtility.WriteAsync(dataFilePath, functionMetadata.TestData);
             }
@@ -161,7 +161,7 @@ await functionMetadata
             FunctionMetadataResponse functionMetadataResult = null;
             if (metadata != null)
             {
-                functionMetadataResult = await GetFunctionMetadataResponseAsync(metadata, hostOptions, request);
+                functionMetadataResult = await GetFunctionMetadataResponseAsync(metadata, hostOptions, request, _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);
                 success = true;
             }
 
@@ -197,7 +197,7 @@ await functionMetadata
 
             if (functionMetadata != null)
             {
-                var functionMetadataResponse = await GetFunctionMetadataResponseAsync(functionMetadata, hostOptions, request);
+                var functionMetadataResponse = await GetFunctionMetadataResponseAsync(functionMetadata, hostOptions, request, _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);
                 return (true, functionMetadataResponse);
             }
             else
@@ -245,11 +245,11 @@ private void DeleteFunctionArtifacts(FunctionMetadataResponse function)
             }
         }
 
-        private static async Task<FunctionMetadataResponse> GetFunctionMetadataResponseAsync(FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, HttpRequest request)
+        private async Task<FunctionMetadataResponse> GetFunctionMetadataResponseAsync(FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, HttpRequest request, bool excludeTestData)
         {
             string routePrefix = await GetRoutePrefix(hostOptions.RootScriptPath);
             var baseUrl = $"{request.Scheme}://{request.Host}";
-            return await functionMetadata.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl);
+            return await functionMetadata.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl, excludeTestData);
         }
 
         // TODO : Due to lifetime scoping issues (this service lifetime is longer than the lifetime
diff --git a/src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs b/src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs
@@ -147,6 +147,22 @@ internal bool EnableOrderedInvocationMessages
             }
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore the TestData property during read and write operations of functions metadata.
+        /// </summary>
+        internal bool IsTestDataSuppressionEnabled
+        {
+            get
+            {
+                return GetFeatureAsBooleanOrDefault(ScriptConstants.FeatureFlagEnableTestDataSuppression, false);
+            }
+
+            set
+            {
+                _features[ScriptConstants.FeatureFlagEnableTestDataSuppression] = value ? "1" : "0";
+            }
+        }
+
         /// <summary>
         /// Gets the highest version of extension bundle v3 supported.
         /// </summary>
diff --git a/src/WebJobs.Script/ScriptConstants.cs b/src/WebJobs.Script/ScriptConstants.cs
@@ -141,6 +141,7 @@ public static class ScriptConstants
         public const string FeatureFlagEnableResponseCompression = "EnableResponseCompression";
         public const string FeatureFlagDisableOrderedInvocationMessages = "DisableOrderedInvocationMessages";
         public const string FeatureFlagEnableAzureMonitorTimeIsoFormat = "EnableAzureMonitorTimeIsoFormat";
+        public const string FeatureFlagEnableTestDataSuppression = "EnableTestDataSuppression";
         public const string HostingConfigDisableLinuxAppServiceDetailedExecutionEvents = "DisableLinuxExecutionDetails";
         public const string HostingConfigDisableLinuxAppServiceExecutionEventLogBackoff = "DisableLinuxLogBackoff";
         public const string FeatureFlagEnableLegacyDurableVersionCheck = "EnableLegacyDurableVersionCheck";
diff --git a/test/WebJobs.Script.Tests/Configuration/FunctionsHostingConfigOptionsTest.cs b/test/WebJobs.Script.Tests/Configuration/FunctionsHostingConfigOptionsTest.cs
@@ -74,6 +74,9 @@ public static IEnumerable<object[]> PropertyValues
                 yield return [ nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=True", true ];
                 yield return [ nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=1", true ];
                 yield return [ nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=0", false ];
+
+                yield return [nameof(FunctionsHostingConfigOptions.IsTestDataSuppressionEnabled), "EnableTestDataSuppression=1", true];
+
 #pragma warning restore SA1011 // Closing square brackets should be spaced correctly
 #pragma warning restore SA1010 // Opening square brackets should be spaced correctly
             }
diff --git a/test/WebJobs.Script.Tests/Extensions/FunctionMetadataExtensionsTests.cs b/test/WebJobs.Script.Tests/Extensions/FunctionMetadataExtensionsTests.cs
@@ -2,9 +2,12 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System.IO;
+using System.IO.Abstractions;
+using System.Text;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.WebHost.Extensions;
+using Moq;
 using Newtonsoft.Json.Linq;
 using Xunit;
 
@@ -168,7 +171,7 @@ public async Task ToFunctionMetadataResponse_WithoutFiles_ReturnsExpected()
             };
 
             AddSampleBindings(functionMetadata);
-            var result = await functionMetadata.ToFunctionMetadataResponse(options, string.Empty, null);
+            var result = await functionMetadata.ToFunctionMetadataResponse(options, string.Empty, null, excludeTestData: false);
 
             Assert.Null(result.ScriptRootPathHref);
             Assert.Null(result.ConfigHref);
@@ -178,6 +181,66 @@ public async Task ToFunctionMetadataResponse_WithoutFiles_ReturnsExpected()
             Assert.Equal("httpTrigger", binding[0]["type"].Value<string>());
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task ToFunctionMetadataResponse_TestData_Exclusion(bool shouldExcludeTestDataFromApiResponse)
+        {
+            var functionName = "TestFunction1";
+            var functionMetadata = new FunctionMetadata
+            {
+                Name = functionName
+            };
+            var testDataFileName = $"{functionName}.dat";
+            var testDataFilePath = Path.Combine(_testRootScriptPath, testDataFileName);
+            var options = new ScriptJobHostOptions
+            {
+                RootScriptPath = _testRootScriptPath,
+                TestDataPath = testDataFilePath
+            };
+
+            IFileSystem fileSystem = FileUtility.Instance;
+
+            try
+            {
+                var testDataContent = @"
+                                    {
+                                        ""method"": ""POST"",
+                                        ""headers"": [],
+                                        ""body"": ""foo""
+                                    }";
+
+                var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(testDataContent))
+                {
+                    Position = 0
+                };
+                // Mock the file system
+                var mockFileSystem = new Mock<IFileSystem>();
+                var mockFile = new Mock<FileBase>();
+                mockFileSystem.Setup(f => f.Directory.Exists(It.IsAny<string>())).Returns(true);
+                mockFile.Setup(f => f.Exists(It.Is<string>(path => path.EndsWith(Path.Combine(functionName, "function.json"))))).Returns(true);
+                mockFile.Setup(f => f.Exists(It.Is<string>(path => path.EndsWith(testDataFileName)))).Returns(true);
+                mockFile.Setup(f => f.Open(It.Is<string>(path => path.EndsWith(testDataFileName)), It.IsAny<FileMode>(), It.IsAny<FileAccess>(), It.IsAny<FileShare>()))
+                        .Returns(memoryStream);
+                mockFileSystem.Setup(fs => fs.File).Returns(mockFile.Object);
+                FileUtility.Instance = mockFileSystem.Object;
+
+                AddSampleBindings(functionMetadata);
+                var result = await functionMetadata.ToFunctionMetadataResponse(options, string.Empty, null, excludeTestData: shouldExcludeTestDataFromApiResponse);
+
+                Assert.Equal(functionName, result.Name);
+                Assert.Equal(shouldExcludeTestDataFromApiResponse, result.TestData == null);
+                if (!shouldExcludeTestDataFromApiResponse)
+                {
+                    Assert.True(result.TestData.Trim().Length > 0);
+                }
+            }
+            finally
+            {
+                FileUtility.Instance = fileSystem;
+            }
+        }
+
         [Fact]
         public void GetFunctionInvokeUrlTemplate_ReturnsExpectedResult()
         {
diff --git a/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs b/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,9 @@ public static class FunctionMetadataExtensions`
`19`	`19`	`/// </summary>`
`20`	`20`	`/// <param name="functionMetadata">FunctionMetadata to be mapped.</param>`
`21`	`21`	`/// <param name="hostOptions">The host options.</param>`
	`22`	`+ /// <param name="excludeTestData">If true, the returned <see cref="FunctionMetadataResponse"/> will not populate the <see cref="FunctionMetadataResponse.TestData"/> property.</param>`
`22`	`23`	`/// <returns>Promise of a FunctionMetadataResponse.</returns>`
`23`		`- public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, string routePrefix, string baseUrl)`
	`24`	`+ public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, string routePrefix, string baseUrl, bool excludeTestData)`
`24`	`25`	`{`
`25`	`26`	`string functionPath = GetFunctionPathOrNull(hostOptions.RootScriptPath, functionMetadata.Name);`
`26`	`27`	`string functionMetadataFilePath = GetMetadataPathOrNull(functionPath);`
`@@ -54,7 +55,7 @@ public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(th`
`54`	`55`	`response.ConfigHref = VirtualFileSystem.FilePathToVfsUri(functionMetadataFilePath, baseUrl, hostOptions);`
`55`	`56`	`}`
`56`	`57`
`57`		`- if (!string.IsNullOrEmpty(hostOptions.TestDataPath))`
	`58`	`+ if (!excludeTestData && !string.IsNullOrEmpty(hostOptions.TestDataPath))`
`58`	`59`	`{`
`59`	`60`	`var testDataFilePath = functionMetadata.GetTestDataFilePath(hostOptions);`
`60`	`61`	`response.TestDataHref = VirtualFileSystem.FilePathToVfsUri(testDataFilePath, baseUrl, hostOptions);`
`@@ -194,7 +195,7 @@ private static JObject GetFunctionConfigFromMetadata(FunctionMetadata metadata)`
`194`	`195`
`195`	`196`	`private static async Task<string> GetTestData(string testDataPath, ScriptJobHostOptions config)`
`196`	`197`	`{`
`197`		`- if (!File.Exists(testDataPath))`
	`198`	`+ if (!FileUtility.FileExists(testDataPath))`
`198`	`199`	`{`
`199`	`200`	`FileUtility.EnsureDirectoryExists(Path.GetDirectoryName(testDataPath));`
`200`	`201`	`await FileUtility.WriteAsync(testDataPath, string.Empty);`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,12 @@`
`7`	`7`	`using System.Linq;`
`8`	`8`	`using System.Net.Http;`
`9`	`9`	`using System.Threading.Tasks;`
`10`		`-using Azure;`
`11`		`-using Azure.Core;`
`12`	`10`	`using Microsoft.AspNetCore.Http;`
	`11`	`+using Microsoft.Azure.WebJobs.Script.Config;`
`13`	`12`	`using Microsoft.Azure.WebJobs.Script.Description;`
`14`	`13`	`using Microsoft.Azure.WebJobs.Script.Management.Models;`
`15`	`14`	`using Microsoft.Azure.WebJobs.Script.WebHost.Extensions;`
`16`	`15`	`using Microsoft.Azure.WebJobs.Script.Workers.Rpc;`
`17`		`-using Microsoft.Extensions.DependencyInjection;`
`18`	`16`	`using Microsoft.Extensions.Logging;`
`19`	`17`	`using Microsoft.Extensions.Options;`
`20`	`18`	`using Newtonsoft.Json;`
`@@ -33,9 +31,10 @@ public class WebFunctionsManager : IWebFunctionsManager`
`33`	`31`	`private readonly IFunctionMetadataManager _functionMetadataManager;`
`34`	`32`	`private readonly IHostFunctionMetadataProvider _hostFunctionMetadataProvider;`
`35`	`33`	`private readonly IOptionsMonitor<LanguageWorkerOptions> _languageWorkerOptions;`
	`34`	`+ private readonly IOptionsMonitor<FunctionsHostingConfigOptions> _hostingConfigOptions;`
`36`	`35`
`37`	`36`	`public WebFunctionsManager(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, ILoggerFactory loggerFactory, IHttpClientFactory httpClientFactory, ISecretManagerProvider secretManagerProvider, IFunctionsSyncManager functionsSyncManager, HostNameProvider hostNameProvider, IFunctionMetadataManager functionMetadataManager, IHostFunctionMetadataProvider hostFunctionMetadataProvider,`
`38`		`- IOptionsMonitor<LanguageWorkerOptions> languageWorkerOptions)`
	`37`	`+ IOptionsMonitor<LanguageWorkerOptions> languageWorkerOptions, IOptionsMonitor<FunctionsHostingConfigOptions> hostingConfigOptions)`
`39`	`38`	`{`
`40`	`39`	`_applicationHostOptions = applicationHostOptions;`
`41`	`40`	`_logger = loggerFactory?.CreateLogger(ScriptConstants.LogCategoryHostGeneral);`
`@@ -46,21 +45,22 @@ public WebFunctionsManager(IOptionsMonitor<ScriptApplicationHostOptions> applica`
`46`	`45`	`_functionMetadataManager = functionMetadataManager;`
`47`	`46`	`_hostFunctionMetadataProvider = hostFunctionMetadataProvider;`
`48`	`47`	`_languageWorkerOptions = languageWorkerOptions;`
	`48`	`+ _hostingConfigOptions = hostingConfigOptions;`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionsMetadata(bool includeProxies)`
`52`	`52`	`{`
`53`	`53`	`var hostOptions = _applicationHostOptions.CurrentValue.ToHostOptions();`
`54`	`54`	`var functionsMetadata = GetFunctionsMetadata(includeProxies, forceRefresh: false);`
`55`	`55`
`56`		`- return await GetFunctionMetadataResponse(functionsMetadata, hostOptions, _hostNameProvider);`
	`56`	`+ return await GetFunctionMetadataResponse(functionsMetadata, hostOptions, _hostNameProvider, excludeTestData: _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);`
`57`	`57`	`}`
`58`	`58`
`59`		`- internal static async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionMetadataResponse(IEnumerable<FunctionMetadata> functionsMetadata, ScriptJobHostOptions hostOptions, HostNameProvider hostNameProvider)`
	`59`	`+ internal static async Task<IEnumerable<FunctionMetadataResponse>> GetFunctionMetadataResponse(IEnumerable<FunctionMetadata> functionsMetadata, ScriptJobHostOptions hostOptions, HostNameProvider hostNameProvider, bool excludeTestData)`
`60`	`60`	`{`
`61`	`61`	`string baseUrl = GetBaseUrl(hostNameProvider);`
`62`	`62`	`string routePrefix = await GetRoutePrefix(hostOptions.RootScriptPath);`
`63`		`- var tasks = functionsMetadata.Select(p => p.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl));`
	`63`	`+ var tasks = functionsMetadata.Select(p => p.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl, excludeTestData));`
`64`	`64`
`65`	`65`	`return await tasks.WhenAll();`
`66`	`66`	`}`
`@@ -148,7 +148,7 @@ await functionMetadata`
`148`	`148`	`configChanged = true;`
`149`	`149`	`}`
`150`	`150`
`151`		`- if (functionMetadata.TestData != null)`
	`151`	`+ if (functionMetadata.TestData != null && !_hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled)`
`152`	`152`	`{`
`153`	`153`	`await FileUtility.WriteAsync(dataFilePath, functionMetadata.TestData);`
`154`	`154`	`}`
`@@ -161,7 +161,7 @@ await functionMetadata`
`161`	`161`	`FunctionMetadataResponse functionMetadataResult = null;`
`162`	`162`	`if (metadata != null)`
`163`	`163`	`{`
`164`		`- functionMetadataResult = await GetFunctionMetadataResponseAsync(metadata, hostOptions, request);`
	`164`	`+ functionMetadataResult = await GetFunctionMetadataResponseAsync(metadata, hostOptions, request, _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);`
`165`	`165`	`success = true;`
`166`	`166`	`}`
`167`	`167`
`@@ -197,7 +197,7 @@ await functionMetadata`
`197`	`197`
`198`	`198`	`if (functionMetadata != null)`
`199`	`199`	`{`
`200`		`- var functionMetadataResponse = await GetFunctionMetadataResponseAsync(functionMetadata, hostOptions, request);`
	`200`	`+ var functionMetadataResponse = await GetFunctionMetadataResponseAsync(functionMetadata, hostOptions, request, _hostingConfigOptions.CurrentValue.IsTestDataSuppressionEnabled);`
`201`	`201`	`return (true, functionMetadataResponse);`
`202`	`202`	`}`
`203`	`203`	`else`
`@@ -245,11 +245,11 @@ private void DeleteFunctionArtifacts(FunctionMetadataResponse function)`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
`248`		`- private static async Task<FunctionMetadataResponse> GetFunctionMetadataResponseAsync(FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, HttpRequest request)`
	`248`	`+ private async Task<FunctionMetadataResponse> GetFunctionMetadataResponseAsync(FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, HttpRequest request, bool excludeTestData)`
`249`	`249`	`{`
`250`	`250`	`string routePrefix = await GetRoutePrefix(hostOptions.RootScriptPath);`
`251`	`251`	`var baseUrl = $"{request.Scheme}://{request.Host}";`
`252`		`- return await functionMetadata.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl);`
	`252`	`+ return await functionMetadata.ToFunctionMetadataResponse(hostOptions, routePrefix, baseUrl, excludeTestData);`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`// TODO : Due to lifetime scoping issues (this service lifetime is longer than the lifetime`