Moved all UnitTests to a single project. Implemented parts of AspNetCore UnitTests.

UnitTests/AspNetCore/Extensions/HttpContextExtensionsTests.cs

@@ -0,0 +1,430 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using Microsoft.AspNetCore.Antiforgery;
+using Microsoft.AspNetCore.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace UnitTests.AspNetCore.Extensions
+{
+	[TestClass]
+	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+	public class HttpContextExtensionsTests
+	{
+		private Mock<ISession> sessionMock;
+
+		private string tokenName;
+		private string tokenValue;
+
+		private Dictionary<string, string> requestHeaders;
+		private Dictionary<string, string> requestQueries;
+		private Dictionary<object, object> items;
+
+		private IPAddress remote;
+
+		[TestInitialize]
+		public void InitializeTests()
+		{
+			tokenName = null;
+			tokenValue = null;
+
+			requestHeaders = new Dictionary<string, string>();
+			requestQueries = new Dictionary<string, string>();
+			items = new Dictionary<object, object>();
+
+			remote = IPAddress.Loopback;
+		}
+
+		#region Antiforgery
+
+		[TestMethod]
+		public void ShouldReturnAntiforgery()
+		{
+			// arrange
+			tokenName = "af-token";
+			tokenValue = "security_first";
+
+			var context = GetContext();
+
+			// act
+			var result = context.GetAntiforgeryToken();
+
+			// assert
+			Assert.AreEqual(tokenName, result.Name);
+			Assert.AreEqual(tokenValue, result.Value);
+		}
+
+		[TestMethod]
+		public void ShouldReturnAntiforgeryNullService()
+		{
+			// arrange
+			tokenName = "af-token";
+			tokenValue = "security_first";
+
+			var context = GetContext(hasAntiforgery: false);
+
+			// act
+			var result = context.GetAntiforgeryToken();
+
+			// assert
+			Assert.AreEqual(null, result.Name);
+			Assert.AreEqual(null, result.Value);
+		}
+
+		[TestMethod]
+		public void ShouldReturnAntiforgeryNullToken()
+		{
+			// arrange
+			var context = GetContext();
+
+			// act
+			var result = context.GetAntiforgeryToken();
+
+			// assert
+			Assert.AreEqual(null, result.Name);
+			Assert.AreEqual(null, result.Value);
+		}
+
+		#endregion Antiforgery
+
+		#region RemoteAddres
+
+		[TestMethod]
+		public void ShouldReturnRemoteAddress()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+
+			var context = GetContext();
+
+			// act
+			var result = context.GetRemoteIpAddress();
+
+			// assert
+			Assert.AreEqual(remote, result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnDefaultHeader()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+			var header = IPAddress.Parse("5.6.7.8");
+			requestHeaders.Add("X-Forwarded-For", header.ToString());
+
+			var context = GetContext();
+
+			// act
+			var result = context.GetRemoteIpAddress();
+
+			// assert
+			Assert.AreNotEqual(remote, result);
+			Assert.AreEqual(header, result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnCustomHeader()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+			string headerName = "FooBar";
+			var headerIp = IPAddress.Parse("5.6.7.8");
+			requestHeaders.Add(headerName, headerIp.ToString());
+
+			var context = GetContext();
+
+			// act
+			var result = context.GetRemoteIpAddress(headerName: headerName);
+
+			// assert
+			Assert.AreNotEqual(remote, result);
+			Assert.AreEqual(headerIp, result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnAddressInvalidHeader()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+			requestHeaders.Add("X-Forwarded-For", "1.2.3:4");
+
+			var context = GetContext();
+
+			// act
+			var result = context.GetRemoteIpAddress();
+
+			// assert
+			Assert.AreEqual(remote, result);
+		}
+
+		#endregion RemoteAddres
+
+		#region Local Request
+
+		[TestMethod]
+		public void ShouldReturnTrueOnLocal()
+		{
+			// arrange
+			remote = IPAddress.Loopback;
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest();
+
+			// assert
+			Assert.IsTrue(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnFalseOnRemote()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest();
+
+			// assert
+			Assert.IsFalse(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnTrueOnDefaultHeader()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+			var headerIp = IPAddress.Loopback;
+			requestHeaders.Add("X-Forwarded-For", headerIp.ToString());
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest();
+
+			// assert
+			Assert.IsTrue(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnTrueOnCustomHeader()
+		{
+			// arrange
+			remote = IPAddress.Parse("1.2.3.4");
+			string headerName = "FooBar";
+			var headerIp = IPAddress.Loopback;
+			requestHeaders.Add(headerName, headerIp.ToString());
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest(headerName: headerName);
+
+			// assert
+			Assert.IsTrue(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnFalseOnDefaultHeader()
+		{
+			// arrange
+			var headerIp = IPAddress.Parse("1.2.3.4");
+			requestHeaders.Add("X-Forwarded-For", headerIp.ToString());
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest();
+
+			// assert
+			Assert.IsFalse(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnFalseOnCustomHeader()
+		{
+			// arrange
+			string headerName = "FooBar";
+			var headerIp = IPAddress.Parse("1.2.3.4");
+			requestHeaders.Add(headerName, headerIp.ToString());
+
+			var context = GetContext();
+
+			// act
+			bool result = context.IsLocalRequest(headerName: headerName);
+
+			// assert
+			Assert.IsFalse(result);
+		}
+
+		#endregion Local Request
+
+		#region ReturnUrl
+
+		[TestMethod]
+		public void ShouldReturnNull()
+		{
+			// arrange
+			var context = GetContext();
+
+			// act
+			string result = context.GetReturnUrl();
+
+			// assert
+			Assert.IsNull(result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnOriginalRequest()
+		{
+			// arrange
+			string request = "abc";
+			string query = "def";
+
+			items.Add("OriginalRequest", request);
+			requestQueries.Add("ReturnUrl", query);
+
+			var context = GetContext();
+
+			// act
+			string result = context.GetReturnUrl();
+
+			// assert
+			Assert.AreEqual(request, result);
+			Assert.AreNotEqual(query, result);
+		}
+
+		[TestMethod]
+		public void ShouldReturnUrl()
+		{
+			// arrange
+			string query = "def";
+			requestQueries.Add("ReturnUrl", query);
+
+			var context = GetContext();
+
+			// act
+			string result = context.GetReturnUrl();
+
+			// assert
+			Assert.AreEqual(query, result);
+		}
+
+		#endregion ReturnUrl
+
+		#region Session
+
+		[TestMethod]
+		public void ShouldClearSession()
+		{
+			// arrange
+			var context = GetContext();
+
+			// act
+			context.ClearSession();
+
+			// assert
+			sessionMock.Verify(s => s.Clear(), Times.Once);
+		}
+
+		[TestMethod]
+		public void ShouldSkipWhenNoSession()
+		{
+			// arrange
+			var context = GetContext(hasSession: false);
+
+			// act
+			context.ClearSession();
+
+			// assert
+			sessionMock.Verify(s => s.Clear(), Times.Never);
+		}
+
+		#endregion Session
+
+		private HttpContext GetContext(bool hasAntiforgery = true, bool hasSession = true)
+		{
+			// Request
+			var requestHeaderMock = new Mock<IHeaderDictionary>();
+			foreach (var header in requestHeaders)
+			{
+				requestHeaderMock
+					.Setup(h => h.ContainsKey(header.Key))
+					.Returns(true);
+				requestHeaderMock
+					.Setup(h => h[header.Key])
+					.Returns(header.Value);
+			}
+
+			var requestQueryMock = new Mock<IQueryCollection>();
+			foreach (var query in requestQueries)
+			{
+				requestQueryMock
+					.Setup(h => h.ContainsKey(query.Key))
+					.Returns(true);
+				requestQueryMock
+					.Setup(h => h[query.Key])
+					.Returns(query.Value);
+			}
+
+			var requestMock = new Mock<HttpRequest>();
+			requestMock
+				.Setup(r => r.Headers)
+				.Returns(requestHeaderMock.Object);
+			requestMock
+				.Setup(r => r.Query)
+				.Returns(requestQueryMock.Object);
+
+			// Request Services
+			var requestServicesMock = new Mock<IServiceProvider>();
+			if (hasAntiforgery)
+			{
+				var antiforgeryMock = new Mock<IAntiforgery>();
+				antiforgeryMock
+					.Setup(af => af.GetAndStoreTokens(It.IsAny<HttpContext>()))
+					.Returns(string.IsNullOrWhiteSpace(tokenName) ? null : new AntiforgeryTokenSet(tokenValue, tokenValue, tokenName, tokenName));
+
+				requestServicesMock
+					.Setup(rs => rs.GetService(typeof(IAntiforgery)))
+					.Returns(antiforgeryMock.Object);
+			}
+
+			// Connection
+			var connectionInfoMock = new Mock<ConnectionInfo>();
+			connectionInfoMock
+				.Setup(ci => ci.LocalIpAddress)
+				.Returns(IPAddress.Loopback);
+			connectionInfoMock
+				.Setup(ci => ci.RemoteIpAddress)
+				.Returns(remote);
+
+			// Session
+			sessionMock = new Mock<ISession>();
+
+			var contextMock = new Mock<HttpContext>();
+			contextMock
+				.Setup(c => c.Request)
+				.Returns(requestMock.Object);
+			contextMock
+				.Setup(c => c.RequestServices)
+				.Returns(requestServicesMock.Object);
+			contextMock
+				.Setup(c => c.Connection)
+				.Returns(connectionInfoMock.Object);
+			contextMock
+				.Setup(c => c.Items)
+				.Returns(items);
+			if (hasSession)
+			{
+				contextMock
+					.Setup(c => c.Session)
+					.Returns(sessionMock.Object);
+			}
+
+			return contextMock.Object;
+		}
+	}
+}

UnitTests/AspNetCore/Extensions/ModelStateDictionaryExtensionsTests.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests.AspNetCore.Extensions
+{
+	[TestClass]
+	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+	public class ModelStateDictionaryExtensionsTests
+	{
+		private TestModel testModel;
+
+		[TestInitialize]
+		public void InitializeTests()
+		{
+			testModel = new TestModel
+			{
+				ValueA = "A",
+				ValueB = "B",
+				SubModel = new TestSubModel
+				{
+					SubValueA = "a",
+					SubValueB = "b"
+				}
+			};
+		}
+
+		[TestMethod]
+		public void ShouldAddNormalModelError()
+		{
+			// arrange
+			var modelState = new ModelStateDictionary();
+
+			// act
+			modelState.AddModelError(testModel, m => m.ValueA, "ShitHappens");
+
+			// assert
+			Assert.AreEqual(1, modelState.Count);
+			Assert.AreEqual("ValueA", modelState.Keys.First());
+			Assert.AreEqual("ShitHappens", modelState.Values.First().Errors.First().ErrorMessage);
+		}
+
+		[TestMethod]
+		public void ShouldAddExtendedModelError()
+		{
+			// arrange
+			var modelState = new ModelStateDictionary();
+
+			// act
+			modelState.AddModelError(testModel, m => m.SubModel.SubValueB, "ShitHappens");
+
+			// assert
+			Assert.AreEqual(1, modelState.Count);
+			Assert.AreEqual("SubModel.SubValueB", modelState.Keys.First());
+			Assert.AreEqual("ShitHappens", modelState.Values.First().Errors.First().ErrorMessage);
+		}
+
+		[TestMethod]
+		[ExpectedException(typeof(ArgumentNullException))]
+		public void ShouldThrowArgumentNull()
+		{
+			// arrange
+			ModelStateDictionary modelState = null;
+
+			// act
+			modelState.AddModelError(testModel, m => m.SubModel.SubValueB, "ShitHappens");
+		}
+
+		[TestMethod]
+		[ExpectedException(typeof(InvalidOperationException))]
+		public void ShouldThrowInvalidOperation()
+		{
+			// arrange
+			var modelState = new ModelStateDictionary();
+
+			// act
+			modelState.AddModelError(testModel, m => m, "ShitHappens");
+		}
+
+		internal class TestModel
+		{
+			public string ValueA { get; set; }
+
+			public string ValueB { get; set; }
+
+			public TestSubModel SubModel { get; set; }
+		}
+
+		internal class TestSubModel
+		{
+			public string SubValueA { get; set; }
+
+			public string SubValueB { get; set; }
+		}
+	}
+}

UnitTests/AspNetCore/Extensions/SessionExtensionsTests.cs

@@ -0,0 +1,159 @@
+using System.Text;
+using Microsoft.AspNetCore.Http;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Newtonsoft.Json;
+
+namespace UnitTests.AspNetCore.Extensions
+{
+	[TestClass]
+	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+	public class SessionExtensionsTests
+	{
+		private Mock<ISession> sessionMock;
+
+		private string sessionKey;
+		private byte[] sessionValue;
+
+		private TestModel model;
+
+		internal class TestModel
+		{
+			public string ValueA { get; set; }
+
+			public string ValueB { get; set; }
+		}
+
+		[TestInitialize]
+		public void InitializeTests()
+		{
+			sessionKey = null;
+			sessionValue = null;
+
+			model = new TestModel
+			{
+				ValueA = "A",
+				ValueB = "B"
+			};
+		}
+
+		[TestMethod]
+		public void ShouldCheckKeyExists()
+		{
+			// arrange
+			sessionKey = "exists";
+			var session = GetSession();
+
+			// act
+			bool result1 = session.HasKey("exists");
+			bool result2 = session.HasKey("somewhere");
+
+			// assert
+			Assert.IsTrue(result1);
+			Assert.IsFalse(result2);
+		}
+
+		[TestMethod]
+		public void ShouldGetValue()
+		{
+			// arrange
+			sessionKey = "test";
+			sessionValue = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(model));
+			var session = GetSession();
+
+			// act
+			var result = session.GetValue<TestModel>(sessionKey);
+
+			// assert
+			Assert.IsNotNull(result);
+			Assert.AreEqual(model.ValueA, result.ValueA);
+			Assert.AreEqual(model.ValueB, result.ValueB);
+		}
+
+		[TestMethod]
+		public void ShouldGetNull()
+		{
+			// arrange
+			sessionKey = "foo";
+			sessionValue = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(model));
+			var session = GetSession();
+
+			// act
+			var result = session.GetValue<TestModel>("bar");
+
+			// assert
+			Assert.IsNull(result);
+		}
+
+		[TestMethod]
+		public void ShouldGetValueWithFallback()
+		{
+			// arrange
+			sessionKey = "test";
+			sessionValue = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(model));
+			var session = GetSession();
+
+			// act
+			var result = session.GetValue(sessionKey, new TestModel());
+
+			// assert
+			Assert.IsNotNull(result);
+			Assert.AreEqual(model.ValueA, result.ValueA);
+			Assert.AreEqual(model.ValueB, result.ValueB);
+		}
+
+		[TestMethod]
+		public void ShouldGetFallback()
+		{
+			// arrange
+			sessionKey = "foo";
+			sessionValue = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(model));
+			var session = GetSession();
+
+			// act
+			var result = session.GetValue("bar", new TestModel());
+
+			// assert
+			Assert.IsNotNull(result);
+			Assert.AreEqual(null, result.ValueA);
+			Assert.AreEqual(null, result.ValueB);
+		}
+
+		[TestMethod]
+		public void ShouldSetValue()
+		{
+			// arrange
+			string key = "foobar";
+			var session = GetSession();
+
+			// act
+			session.SetValue(key, model);
+
+			// arrange
+			Assert.AreEqual(key, sessionKey);
+			Assert.AreEqual(JsonConvert.SerializeObject(model), Encoding.UTF8.GetString(sessionValue));
+		}
+
+		private ISession GetSession()
+		{
+			string[] keys = new[] { sessionKey };
+
+			sessionMock = new Mock<ISession>();
+			sessionMock
+				.Setup(s => s.TryGetValue(It.IsAny<string>(), out sessionValue))
+				.Returns<string, byte[]>((key, value) => sessionKey == key);
+			sessionMock
+				.Setup(s => s.Set(It.IsAny<string>(), It.IsAny<byte[]>()))
+				.Callback<string, byte[]>((key, value) =>
+				{
+					sessionKey = key;
+					sessionValue = value;
+				});
+			sessionMock
+				.Setup(s => s.Keys)
+				.Returns(keys);
+
+			return sessionMock.Object;
+		}
+	}
+}