Move file cache hashing into separate class and fix unit tests

Author: Daniel15

src/React.Tests/Core/FileCacheHashTests.cs

@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using NUnit.Framework;
+
+namespace React.Tests.Core
+{
+	[TestFixture]
+	public class FileCacheHashTests
+	{
+		private const string SAMPLE_HASH = "B10A8DB164E0754105B7A99BE72E3FE5";
+
+		[Test]
+		public void TestCalculateHash()
+		{
+			var hash = new FileCacheHash();
+			Assert.AreEqual(SAMPLE_HASH, hash.CalculateHash("Hello World"));
+		}
+
+		[Test]
+		public void ValidateHashShouldReturnFalseForEmptyString()
+		{
+			var hash = new FileCacheHash();
+			Assert.IsFalse(hash.ValidateHash(string.Empty, SAMPLE_HASH));
+		}
+
+		[Test]
+		public void ValidateHashShouldReturnFalseForNull()
+		{
+			var hash = new FileCacheHash();
+			Assert.IsFalse(hash.ValidateHash(null, SAMPLE_HASH));
+		}
+
+		[Test]
+		public void ValidateHashShouldReturnFalseWhenNoHashPrefix()
+		{
+			var hash = new FileCacheHash();
+			Assert.IsFalse(hash.ValidateHash("Hello World", SAMPLE_HASH));
+		}
+
+		[Test]
+		public void ValidateHashShouldReturnFalseWhenHashDoesNotMatch()
+		{
+			var hash = new FileCacheHash();
+			Assert.IsFalse(hash.ValidateHash("// @hash NOTCORRECT\nHello World", SAMPLE_HASH));
+		}
+
+		[Test]
+		public void ValidateHashShouldReturnTrueWhenHashMatches()
+		{
+			var hash = new FileCacheHash();
+			Assert.IsTrue(hash.ValidateHash("// @hash " + SAMPLE_HASH + "\nHello World", SAMPLE_HASH));
+		}
+	}
+}

src/React.Tests/Core/JsxTransformerTests.cs

@@ -21,6 +21,7 @@ public class JsxTransformerTests
 		private Mock<IReactEnvironment> _environment;
 		private Mock<ICache> _cache;
 		private Mock<IFileSystem> _fileSystem;
+		private Mock<IFileCacheHash> _fileCacheHash; 
 		private JsxTransformer _jsxTransformer;
 
 		[SetUp]
@@ -33,10 +34,13 @@ public void SetUp()
 			_fileSystem = new Mock<IFileSystem>();
 			_fileSystem.Setup(x => x.MapPath(It.IsAny<string>())).Returns<string>(x => x);
 
+			_fileCacheHash = new Mock<IFileCacheHash>();
+
 			_jsxTransformer = new JsxTransformer(
 				_environment.Object,
 				_cache.Object,
-				_fileSystem.Object
+				_fileSystem.Object,
+				_fileCacheHash.Object
 			);
 		}
 
@@ -98,17 +102,32 @@ public void ShouldUseCacheProvider()
 		}
 
 		[Test]
-		[Ignore("Needs to be fixed")]
-		public void ShouldUseFileSystemCache()
+		public void ShouldUseFileSystemCacheIfHashValid()
 		{
 			SetUpEmptyCache();
 			_fileSystem.Setup(x => x.FileExists("foo.generated.js")).Returns(true);
 			_fileSystem.Setup(x => x.ReadAsString("foo.generated.js")).Returns("/* filesystem cached */");
+			_fileCacheHash.Setup(x => x.ValidateHash(It.IsAny<string>(), It.IsAny<string>())).Returns(true);
 
 			var result = _jsxTransformer.TransformJsxFile("foo.jsx");
 			Assert.AreEqual("/* filesystem cached */", result);
 		}
 
+		[Test]
+		public void ShouldTransformJsxIfFileCacheHashInvalid()
+		{
+			SetUpEmptyCache();
+			_fileSystem.Setup(x => x.FileExists("foo.generated.js")).Returns(true);
+			_fileSystem.Setup(x => x.ReadAsString("foo.generated.js")).Returns("/* filesystem cached invalid */");
+			_fileSystem.Setup(x => x.ReadAsString("foo.jsx")).Returns("/** @jsx React.DOM */ <div>Hello World</div>");
+			_fileCacheHash.Setup(x => x.ValidateHash(It.IsAny<string>(), It.IsAny<string>())).Returns(false);
+
+			_jsxTransformer.TransformJsxFile("foo.jsx");
+			_environment.Verify(x => x.ExecuteWithLargerStackIfRequired<string>(
+				@"global.JSXTransformer.transform(""/** @jsx React.DOM */ <div>Hello World</div>"").code"
+			));
+		}
+
 		[Test]
 		public void ShouldTransformJsxIfNoCache()
 		{
@@ -123,17 +142,21 @@ public void ShouldTransformJsxIfNoCache()
 		}
 
 		[Test]
-		[Ignore("Needs to be fixed")]
 		public void ShouldSaveTransformationResult()
 		{
 			_fileSystem.Setup(x => x.ReadAsString("foo.jsx")).Returns("/** @jsx React.DOM */ <div>Hello World</div>");
 			_environment.Setup(x => x.ExecuteWithLargerStackIfRequired<string>(
 				@"global.JSXTransformer.transform(""/** @jsx React.DOM */ <div>Hello World</div>"").code"
 			)).Returns("React.DOM.div('Hello World')");
 
-			var result = _jsxTransformer.TransformAndSaveJsxFile("foo.jsx");
-			Assert.AreEqual("foo.generated.js", result);
-			_fileSystem.Verify(x => x.WriteAsString("foo.generated.js", "React.DOM.div('Hello World')"));
+			string result = null;
+			_fileSystem.Setup(x => x.WriteAsString("foo.generated.js", It.IsAny<string>())).Callback(
+				(string filename, string contents) => result = contents
+			);
+
+			var resultFilename = _jsxTransformer.TransformAndSaveJsxFile("foo.jsx");
+			Assert.AreEqual("foo.generated.js", resultFilename);
+			StringAssert.EndsWith("React.DOM.div('Hello World')", result);
 		}
 
 		private void SetUpEmptyCache()

src/React.Tests/Core/ReactEnvironmentTest.cs

@@ -73,13 +73,15 @@ private class Mocks
 			public Mock<IReactSiteConfiguration> Config { get; private set; }
 			public Mock<ICache> Cache { get; private set; }
 			public Mock<IFileSystem> FileSystem { get; private set; }
+			public Mock<IFileCacheHash> FileCacheHash { get; private set; }
 			public Mocks()
 			{
 				Engine = new Mock<IJsEngine>();
 				EngineFactory = new Mock<IJavaScriptEngineFactory>();
 				Config = new Mock<IReactSiteConfiguration>();
 				Cache = new Mock<ICache>();
 				FileSystem = new Mock<IFileSystem>();
+				FileCacheHash = new Mock<IFileCacheHash>();
 
 				EngineFactory.Setup(x => x.GetEngineForCurrentThread(It.IsAny<Action<IJsEngine>>())).Returns(Engine.Object);
 			}
@@ -90,7 +92,8 @@ public ReactEnvironment CreateReactEnvironment()
 					EngineFactory.Object,
 					Config.Object,
 					Cache.Object,
-					FileSystem.Object
+					FileSystem.Object,
+					FileCacheHash.Object
 				);
 			}
 		}

src/React.Tests/React.Tests.csproj

@@ -66,6 +66,7 @@
     <Compile Include="..\SharedAssemblyVersionInfo.cs">
       <Link>Properties\SharedAssemblyVersionInfo.cs</Link>
     </Compile>
+    <Compile Include="Core\FileCacheHashTests.cs" />
     <Compile Include="Core\JavaScriptEngineFactoryTest.cs" />
     <Compile Include="Core\JsxTransformerTests.cs" />
     <Compile Include="Core\ReactComponentTest.cs" />

src/React/AssemblyRegistration.cs

@@ -35,12 +35,7 @@ public void Register(TinyIoCContainer container)
 		{
 			// One instance shared for the whole app
 			container.Register<IReactSiteConfiguration>((c, o) => ReactSiteConfiguration.Configuration);
-			// Force MSIE to use Chakra ActiveScript engine.
-			// Chakra JS RT engine runs out of stack space when processing JSX
-			container.Register<MsieConfiguration>(new MsieConfiguration
-			{
-				EngineMode = JsEngineMode.ChakraActiveScript
-			});
+			container.Register<IFileCacheHash, FileCacheHash>().AsSingleton();
 
 			container.Register<IReactEnvironment, ReactEnvironment>().AsPerRequestSingleton();
 			container.Register<IJavaScriptEngineFactory, JavaScriptEngineFactory>().AsPerRequestSingleton();

src/React/FileCacheHash.cs

@@ -0,0 +1,83 @@
+/*
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace React
+{
+	/// <summary>
+	/// Handles calculating a hash value for validating a file-based cache.
+	/// </summary>
+	public class FileCacheHash : IFileCacheHash
+	{
+		/// <summary>
+		/// Prefix used for hash line in transformed file. Used for caching.
+		/// </summary>
+		internal const string HASH_PREFIX = "// @hash ";
+
+		/// <summary>
+		/// Althorithm for calculating file hashes
+		/// </summary>
+		private readonly HashAlgorithm _hash = MD5.Create();
+
+		/// <summary>
+		/// Calculates a hash for the specified input
+		/// </summary>
+		/// <param name="input">Input string</param>
+		/// <returns>Hash of the input</returns>
+		public string CalculateHash(string input)
+		{
+			var inputBytes = Encoding.UTF8.GetBytes(input);
+			var hash = _hash.ComputeHash(inputBytes);
+			return BitConverter.ToString(hash).Replace("-", string.Empty);
+		}
+
+		/// <summary>
+		/// Validates that the cache's hash is valid. This is used to ensure the input has not
+		/// changed, and to invalidate the cache if so.
+		/// </summary>
+		/// <param name="cacheContents">Contents retrieved from cache</param>
+		/// <param name="hash">Hash of the input</param>
+		/// <returns><c>true</c> if the cache is still valid</returns>
+		public bool ValidateHash(string cacheContents, string hash)
+		{
+			if (string.IsNullOrWhiteSpace(cacheContents))
+			{
+				return false;
+			}
+
+			// Check if first line is hash
+			var firstLineBreak = cacheContents.IndexOfAny(new[] { '\r', '\n' });
+			if (firstLineBreak == -1)
+			{
+				return false;
+			}
+			var firstLine = cacheContents.Substring(0, firstLineBreak);
+			if (!firstLine.StartsWith(HASH_PREFIX))
+			{
+				// Cache doesn't have hash - Err on the side of caution and invalidate it.
+				return false;
+			}
+			var cacheHash = firstLine.Replace(HASH_PREFIX, string.Empty);
+			return cacheHash == hash;
+		}
+
+		/// <summary>
+		/// Prepends the hash prefix to the hash
+		/// </summary>
+		/// <param name="hash">Hash to prepend prefix to</param>
+		/// <returns>Hash with prefix</returns>
+		public string AddPrefix(string hash)
+		{
+			return HASH_PREFIX + hash;
+		}
+	}
+}

src/React/IFileCacheHash.cs

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant 
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace React
+{
+	/// <summary>
+	/// Handles calculating a hash value for validating a file-based cache.
+	/// </summary>
+	public interface IFileCacheHash
+	{
+		/// <summary>
+		/// Calculates a hash for the specified input
+		/// </summary>
+		/// <param name="input">Input string</param>
+		/// <returns>Hash of the input</returns>
+		string CalculateHash(string input);
+
+		/// <summary>
+		/// Validates that the cache's hash is valid. This is used to ensure the input has not
+		/// changed, and to invalidate the cache if so.
+		/// </summary>
+		/// <param name="cacheContents">Contents retrieved from cache</param>
+		/// <param name="hash">Hash of the input</param>
+		/// <returns><c>true</c> if the cache is still valid</returns>
+		bool ValidateHash(string cacheContents, string hash);
+
+		/// <summary>
+		/// Prepends the hash prefix to the hash
+		/// </summary>
+		/// <param name="hash">Hash to prepend prefix to</param>
+		/// <returns>Hash with prefix</returns>
+		string AddPrefix(string hash);
+	}
+}