Support WEBSITE_AUTH_ENCRYPTION_KEY and fix SA warning

suwatch · suwatch · commit 37b9f7a89e5f · 2017-11-01T18:44:39.000-07:00
diff --git a/build.cmd b/build.cmd
@@ -1,8 +1,5 @@
 @ECHO Off
-
-SET Config=%1
-IF "%1"=="" (
-  SET Config="Release"
-)
-
-msbuild WebJobs.Script.proj /p:Configuration=%Config%;SolutionDir=%~dp0 /flp:LogFile=msbuild.log;Verbosity=Normal
+REM call dotnet --version
+call dotnet restore WebJobs.Script.sln
+call dotnet build WebJobs.Script.sln
+REM call dotnet test WebJobs.Script.sln --no-build
diff --git a/src/WebJobs.Script.Scaling/AppServiceSettings.cs b/src/WebJobs.Script.Scaling/AppServiceSettings.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Microsoft.Win32;
 
 namespace Microsoft.Azure.WebJobs.Script.Scaling
@@ -259,19 +260,31 @@ public static byte[] RuntimeEncryptionKey
             {
                 if (_runtimeEncryptionKey == null)
                 {
-                    var value = Environment.GetEnvironmentVariable("WEBSITE_ENCRYPTION_KEY");
+                    var value = Environment.GetEnvironmentVariable("WEBSITE_AUTH_ENCRYPTION_KEY");
                     if (string.IsNullOrEmpty(value))
                     {
-                        throw new InvalidOperationException("MIssing WEBSITE_ENCRYPTION_KEY environment variable");
+                        throw new InvalidOperationException("Missing WEBSITE_AUTH_ENCRYPTION_KEY environment variable");
                     }
 
                     try
                     {
-                        _runtimeEncryptionKey = Convert.FromBase64String(value);
+                        // only support 32 bytes (256 bits) key length
+                        // either hex or base64 string format
+                        if (value.Length == 64)
+                        {
+                            _runtimeEncryptionKey = Enumerable.Range(0, value.Length)
+                                             .Where(x => x % 2 == 0)
+                                             .Select(x => Convert.ToByte(value.Substring(x, 2), 16))
+                                             .ToArray();
+                        }
+                        else
+                        {
+                            _runtimeEncryptionKey = Convert.FromBase64String(value);
+                        }
                     }
                     catch (Exception ex)
                     {
-                        throw new InvalidOperationException(string.Format("Invalid base64 WEBSITE_ENCRYPTION_KEY environment variable '{0}'.", value), ex);
+                        throw new InvalidOperationException(string.Format("Invalid base64 WEBSITE_AUTH_ENCRYPTION_KEY environment variable '{0}'.", value), ex);
                     }
                 }
 
diff --git a/src/WebJobs.Script.Scaling/ScaleUtils.cs b/src/WebJobs.Script.Scaling/ScaleUtils.cs
@@ -109,24 +109,32 @@ public static string GetToken(DateTime expiredUtc)
                         cs.FlushFinalBlock();
                     }
 
-                    return string.Format("{0}.{1}", iv, Convert.ToBase64String(ms.ToArray()));
+                    return string.Format("{0}.{1}.{2}", iv, Convert.ToBase64String(ms.ToArray()), GetSHA256Base64String(aes.Key));
                 }
             }
         }
 
         public static void ValidateToken(string token)
         {
             var parts = token.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
-            if (parts.Length != 2)
+            if (parts.Length != 2 && parts.Length != 3)
             {
                 throw new ArgumentException("Malform encrypted data.");
             }
 
             var iv = Convert.FromBase64String(parts[0]);
             var data = Convert.FromBase64String(parts[1]);
+            var base64KeyHash = parts.Length == 3 ? parts[2] : null;
+
+            var encryptionKey = AppServiceSettings.RuntimeEncryptionKey;
+            if (!string.IsNullOrEmpty(base64KeyHash) && !string.Equals(GetSHA256Base64String(encryptionKey), base64KeyHash))
+            {
+                throw new InvalidOperationException(string.Format("Key with hash {0} does not exist.", base64KeyHash));
+            }
+
             using (var aes = new AesManaged())
             {
-                aes.Key = AppServiceSettings.RuntimeEncryptionKey;
+                aes.Key = encryptionKey;
 
                 using (var decrypter = aes.CreateDecryptor(aes.Key, iv))
                 using (var ms = new MemoryStream())
@@ -152,5 +160,13 @@ public static void ValidateToken(string token)
                 }
             }
         }
+
+        private static string GetSHA256Base64String(byte[] key)
+        {
+            using (var sha256 = new SHA256Managed())
+            {
+                return Convert.ToBase64String(sha256.ComputeHash(key));
+            }
+        }
     }
 }
diff --git a/test/WebJobs.Script.Scaling.Tests/AppServiceScaleManagerTests.cs b/test/WebJobs.Script.Scaling.Tests/AppServiceScaleManagerTests.cs
@@ -14,7 +14,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
     [Collection("Azure Test Collection")]
     public class AppServiceScaleManagerTests
     {
-        [Theory, MemberData("SupportedData")]
+        [Theory, MemberData(nameof(SupportedData))]
         public void SupportedTests(bool runtimeScaleEnabled, string storageConnectionString, string sku, bool expected)
         {
             AppServiceSettings.RuntimeScalingEnabled = runtimeScaleEnabled;
diff --git a/test/WebJobs.Script.Scaling.Tests/AppServiceWorkerTableTests.cs b/test/WebJobs.Script.Scaling.Tests/AppServiceWorkerTableTests.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
     [Collection("Azure Test Collection")]
     public class AppServiceWorkerTableTests
     {
-        [Theory, MemberData("TestStorageConnectionString")]
+        [Theory, MemberData(nameof(TestStorageConnectionString))]
         public async Task CRUDTests(string storageConnectionString, string siteName)
         {
             if (string.IsNullOrEmpty(storageConnectionString))
@@ -81,7 +81,7 @@ public async Task CRUDTests(string storageConnectionString, string siteName)
             }
         }
 
-        [Theory, MemberData("TestStorageConnectionString")]
+        [Theory, MemberData(nameof(TestStorageConnectionString))]
         public async Task GetSetManagerTests(string storageConnectionString, string siteName)
         {
             if (string.IsNullOrEmpty(storageConnectionString))
@@ -132,7 +132,7 @@ public async Task GetSetManagerTests(string storageConnectionString, string site
             }
         }
 
-        [Theory, MemberData("TestStorageConnectionString")]
+        [Theory, MemberData(nameof(TestStorageConnectionString))]
         public async Task LeaseBasicTests(string storageConnectionString, string siteName)
         {
             if (string.IsNullOrEmpty(storageConnectionString))
@@ -173,7 +173,7 @@ public async Task LeaseBasicTests(string storageConnectionString, string siteNam
             }
         }
 
-        [Theory, MemberData("TestStorageConnectionString")]
+        [Theory, MemberData(nameof(TestStorageConnectionString))]
         public async Task LeaseConflictTests(string storageConnectionString, string siteName)
         {
             if (string.IsNullOrEmpty(storageConnectionString))
diff --git a/test/WebJobs.Script.Scaling.Tests/EnsureManagerTests.cs b/test/WebJobs.Script.Scaling.Tests/EnsureManagerTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class EnsureManagerTests
     {
-        [Theory, MemberData("EnsureManagerData")]
+        [Theory, MemberData(nameof(EnsureManagerData))]
         public async Task BasicTests(IWorkerInfo worker, IWorkerInfo current, IEnumerable<IWorkerInfo> workers, IWorkerInfo expected)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/ProcessWorkItemTests.cs b/test/WebJobs.Script.Scaling.Tests/ProcessWorkItemTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class ProcessWorkItemTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(IWorkerInfo worker, IWorkerInfo current)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/RequestAddWorkerTests.cs b/test/WebJobs.Script.Scaling.Tests/RequestAddWorkerTests.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class RequestAddWorkerTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(int maxWorkers, IEnumerable<IWorkerInfo> workers, IWorkerInfo manager, bool force, bool expected)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/RequestRemoveWorkerTests.cs b/test/WebJobs.Script.Scaling.Tests/RequestRemoveWorkerTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class RequestRemoveWorkerTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(IWorkerInfo manager, IWorkerInfo toRemove)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/ScaleUtilsTests.cs b/test/WebJobs.Script.Scaling.Tests/ScaleUtilsTests.cs
@@ -13,7 +13,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class ScaleUtilsTests
     {
-        [Theory, MemberData("WorkerEqualsData")]
+        [Theory, MemberData(nameof(WorkerEqualsData))]
         public void WorkerEqualsTests(IWorkerInfo src, IWorkerInfo dst, bool expected)
         {
             var actual = ScaleUtils.WorkerEquals(src, dst);
@@ -119,7 +119,7 @@ public void WorkersToDisplayStringTests()
         public void GetAndValidateTokenTests(DateTime expiredUtc, bool expected)
         {
             var encryptionKey = GenerateEncryptionKey();
-            using (new TestScopedEnvironmentVariable("WEBSITE_ENCRYPTION_KEY", Convert.ToBase64String(encryptionKey)))
+            using (new TestScopedEnvironmentVariable("WEBSITE_AUTH_ENCRYPTION_KEY", Convert.ToBase64String(encryptionKey)))
             {
                 var token = ScaleUtils.GetToken(expiredUtc);
 
diff --git a/test/WebJobs.Script.Scaling.Tests/SetManagerTests.cs b/test/WebJobs.Script.Scaling.Tests/SetManagerTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class SetManagerTests
     {
-        [Theory, MemberData("SuccessfulSetData")]
+        [Theory, MemberData(nameof(SuccessfulSetData))]
         public async Task SuccessfulSetTests(IWorkerInfo worker, IWorkerInfo current)
         {
             var activityId = Guid.NewGuid().ToString();
@@ -60,7 +60,7 @@ public static IEnumerable<object[]> SuccessfulSetData
             }
         }
 
-        [Theory, MemberData("AlreadySetData")]
+        [Theory, MemberData(nameof(AlreadySetData))]
         public async Task AlreadySetTests(IWorkerInfo worker, IWorkerInfo current, IWorkerInfo other)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TryAddIfLoadFactorMaxWorkerTests.cs b/test/WebJobs.Script.Scaling.Tests/TryAddIfLoadFactorMaxWorkerTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TryAddIfLoadFactorMaxWorkerTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, IWorkerInfo loadFactorMaxWorker)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TryAddIfMaxBusyWorkerRatioTests.cs b/test/WebJobs.Script.Scaling.Tests/TryAddIfMaxBusyWorkerRatioTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TryAddIfMaxBusyWorkerRatioTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(double maxBusyWorkerRatio, IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, bool expected)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TryRemoveIfMaxFreeWorkerRatioTests.cs b/test/WebJobs.Script.Scaling.Tests/TryRemoveIfMaxFreeWorkerRatioTests.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TryRemoveIfMaxFreeWorkerRatioTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(double maxFreeWorkerRatio, IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, IWorkerInfo toRemove)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TryRemoveIfMaxWorkersTests.cs b/test/WebJobs.Script.Scaling.Tests/TryRemoveIfMaxWorkersTests.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TryRemoveIfMaxWorkersTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(int maxWorkers, IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, IEnumerable<IWorkerInfo> toRemoves)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TryRemoveSlaveWorkerTests.cs b/test/WebJobs.Script.Scaling.Tests/TryRemoveSlaveWorkerTests.cs
@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TryRemoveSlaveWorkerTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, bool added, IWorkerInfo toRemove)
         {
             var activityId = Guid.NewGuid().ToString();
diff --git a/test/WebJobs.Script.Scaling.Tests/TrySwapIfLoadFactorMinWorkerTests.cs b/test/WebJobs.Script.Scaling.Tests/TrySwapIfLoadFactorMinWorkerTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests
 {
     public class TrySwapIfLoadFactorMinWorkerTests
     {
-        [Theory, MemberData("BasicData")]
+        [Theory, MemberData(nameof(BasicData))]
         public async Task BasicTests(IWorkerInfo manager, IEnumerable<IWorkerInfo> workers, IWorkerInfo loadFactorMinWorker)
         {
             var activityId = Guid.NewGuid().ToString();

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Diagnostics.CodeAnalysis;`
	`6`	`+using System.Linq;`
`6`	`7`	`using Microsoft.Win32;`
`7`	`8`
`8`	`9`	`namespace Microsoft.Azure.WebJobs.Script.Scaling`
`@@ -259,19 +260,31 @@ public static byte[] RuntimeEncryptionKey`
`259`	`260`	`{`
`260`	`261`	`if (_runtimeEncryptionKey == null)`
`261`	`262`	`{`
`262`		`- var value = Environment.GetEnvironmentVariable("WEBSITE_ENCRYPTION_KEY");`
	`263`	`+ var value = Environment.GetEnvironmentVariable("WEBSITE_AUTH_ENCRYPTION_KEY");`
`263`	`264`	`if (string.IsNullOrEmpty(value))`
`264`	`265`	`{`
`265`		`- throw new InvalidOperationException("MIssing WEBSITE_ENCRYPTION_KEY environment variable");`
	`266`	`+ throw new InvalidOperationException("Missing WEBSITE_AUTH_ENCRYPTION_KEY environment variable");`
`266`	`267`	`}`
`267`	`268`
`268`	`269`	`try`
`269`	`270`	`{`
`270`		`- _runtimeEncryptionKey = Convert.FromBase64String(value);`
	`271`	`+ // only support 32 bytes (256 bits) key length`
	`272`	`+ // either hex or base64 string format`
	`273`	`+ if (value.Length == 64)`
	`274`	`+ {`
	`275`	`+ _runtimeEncryptionKey = Enumerable.Range(0, value.Length)`
	`276`	`+ .Where(x => x % 2 == 0)`
	`277`	`+ .Select(x => Convert.ToByte(value.Substring(x, 2), 16))`
	`278`	`+ .ToArray();`
	`279`	`+ }`
	`280`	`+ else`
	`281`	`+ {`
	`282`	`+ _runtimeEncryptionKey = Convert.FromBase64String(value);`
	`283`	`+ }`
`271`	`284`	`}`
`272`	`285`	`catch (Exception ex)`
`273`	`286`	`{`
`274`		`- throw new InvalidOperationException(string.Format("Invalid base64 WEBSITE_ENCRYPTION_KEY environment variable '{0}'.", value), ex);`
	`287`	`+ throw new InvalidOperationException(string.Format("Invalid base64 WEBSITE_AUTH_ENCRYPTION_KEY environment variable '{0}'.", value), ex);`
`275`	`288`	`}`
`276`	`289`	`}`
`277`	`290`
Original file line number	Diff line number	Diff line change
`@@ -109,24 +109,32 @@ public static string GetToken(DateTime expiredUtc)`
`109`	`109`	`cs.FlushFinalBlock();`
`110`	`110`	`}`
`111`	`111`
`112`		`- return string.Format("{0}.{1}", iv, Convert.ToBase64String(ms.ToArray()));`
	`112`	`+ return string.Format("{0}.{1}.{2}", iv, Convert.ToBase64String(ms.ToArray()), GetSHA256Base64String(aes.Key));`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`public static void ValidateToken(string token)`
`118`	`118`	`{`
`119`	`119`	`var parts = token.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);`
`120`		`- if (parts.Length != 2)`
	`120`	`+ if (parts.Length != 2 && parts.Length != 3)`
`121`	`121`	`{`
`122`	`122`	`throw new ArgumentException("Malform encrypted data.");`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`var iv = Convert.FromBase64String(parts[0]);`
`126`	`126`	`var data = Convert.FromBase64String(parts[1]);`
	`127`	`+ var base64KeyHash = parts.Length == 3 ? parts[2] : null;`
	`128`	`+`
	`129`	`+ var encryptionKey = AppServiceSettings.RuntimeEncryptionKey;`
	`130`	`+ if (!string.IsNullOrEmpty(base64KeyHash) && !string.Equals(GetSHA256Base64String(encryptionKey), base64KeyHash))`
	`131`	`+ {`
	`132`	`+ throw new InvalidOperationException(string.Format("Key with hash {0} does not exist.", base64KeyHash));`
	`133`	`+ }`
	`134`	`+`
`127`	`135`	`using (var aes = new AesManaged())`
`128`	`136`	`{`
`129`		`- aes.Key = AppServiceSettings.RuntimeEncryptionKey;`
	`137`	`+ aes.Key = encryptionKey;`
`130`	`138`
`131`	`139`	`using (var decrypter = aes.CreateDecryptor(aes.Key, iv))`
`132`	`140`	`using (var ms = new MemoryStream())`
`@@ -152,5 +160,13 @@ public static void ValidateToken(string token)`
`152`	`160`	`}`
`153`	`161`	`}`
`154`	`162`	`}`
	`163`	`+`
	`164`	`+ private static string GetSHA256Base64String(byte[] key)`
	`165`	`+ {`
	`166`	`+ using (var sha256 = new SHA256Managed())`
	`167`	`+ {`
	`168`	`+ return Convert.ToBase64String(sha256.ComputeHash(key));`
	`169`	`+ }`
	`170`	`+ }`
`155`	`171`	`}`
`156`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests`
`14`	`14`	`[Collection("Azure Test Collection")]`
`15`	`15`	`public class AppServiceScaleManagerTests`
`16`	`16`	`{`
`17`		`- [Theory, MemberData("SupportedData")]`
	`17`	`+ [Theory, MemberData(nameof(SupportedData))]`
`18`	`18`	`public void SupportedTests(bool runtimeScaleEnabled, string storageConnectionString, string sku, bool expected)`
`19`	`19`	`{`
`20`	`20`	`AppServiceSettings.RuntimeScalingEnabled = runtimeScaleEnabled;`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests`
`12`	`12`	`[Collection("Azure Test Collection")]`
`13`	`13`	`public class AppServiceWorkerTableTests`
`14`	`14`	`{`
`15`		`- [Theory, MemberData("TestStorageConnectionString")]`
	`15`	`+ [Theory, MemberData(nameof(TestStorageConnectionString))]`
`16`	`16`	`public async Task CRUDTests(string storageConnectionString, string siteName)`
`17`	`17`	`{`
`18`	`18`	`if (string.IsNullOrEmpty(storageConnectionString))`
`@@ -81,7 +81,7 @@ public async Task CRUDTests(string storageConnectionString, string siteName)`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`- [Theory, MemberData("TestStorageConnectionString")]`
	`84`	`+ [Theory, MemberData(nameof(TestStorageConnectionString))]`
`85`	`85`	`public async Task GetSetManagerTests(string storageConnectionString, string siteName)`
`86`	`86`	`{`
`87`	`87`	`if (string.IsNullOrEmpty(storageConnectionString))`
`@@ -132,7 +132,7 @@ public async Task GetSetManagerTests(string storageConnectionString, string site`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`		`- [Theory, MemberData("TestStorageConnectionString")]`
	`135`	`+ [Theory, MemberData(nameof(TestStorageConnectionString))]`
`136`	`136`	`public async Task LeaseBasicTests(string storageConnectionString, string siteName)`
`137`	`137`	`{`
`138`	`138`	`if (string.IsNullOrEmpty(storageConnectionString))`
`@@ -173,7 +173,7 @@ public async Task LeaseBasicTests(string storageConnectionString, string siteNam`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`		`- [Theory, MemberData("TestStorageConnectionString")]`
	`176`	`+ [Theory, MemberData(nameof(TestStorageConnectionString))]`
`177`	`177`	`public async Task LeaseConflictTests(string storageConnectionString, string siteName)`
`178`	`178`	`{`
`179`	`179`	`if (string.IsNullOrEmpty(storageConnectionString))`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests`
`11`	`11`	`{`
`12`	`12`	`public class EnsureManagerTests`
`13`	`13`	`{`
`14`		`- [Theory, MemberData("EnsureManagerData")]`
	`14`	`+ [Theory, MemberData(nameof(EnsureManagerData))]`
`15`	`15`	`public async Task BasicTests(IWorkerInfo worker, IWorkerInfo current, IEnumerable<IWorkerInfo> workers, IWorkerInfo expected)`
`16`	`16`	`{`
`17`	`17`	`var activityId = Guid.NewGuid().ToString();`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.Azure.WebJobs.Script.Scaling.Tests`
`13`	`13`	`{`
`14`	`14`	`public class ScaleUtilsTests`
`15`	`15`	`{`
`16`		`- [Theory, MemberData("WorkerEqualsData")]`
	`16`	`+ [Theory, MemberData(nameof(WorkerEqualsData))]`
`17`	`17`	`public void WorkerEqualsTests(IWorkerInfo src, IWorkerInfo dst, bool expected)`
`18`	`18`	`{`
`19`	`19`	`var actual = ScaleUtils.WorkerEquals(src, dst);`
`@@ -119,7 +119,7 @@ public void WorkersToDisplayStringTests()`
`119`	`119`	`public void GetAndValidateTokenTests(DateTime expiredUtc, bool expected)`
`120`	`120`	`{`
`121`	`121`	`var encryptionKey = GenerateEncryptionKey();`
`122`		`- using (new TestScopedEnvironmentVariable("WEBSITE_ENCRYPTION_KEY", Convert.ToBase64String(encryptionKey)))`
	`122`	`+ using (new TestScopedEnvironmentVariable("WEBSITE_AUTH_ENCRYPTION_KEY", Convert.ToBase64String(encryptionKey)))`
`123`	`123`	`{`
`124`	`124`	`var token = ScaleUtils.GetToken(expiredUtc);`
`125`	`125`