Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/WebMatrix.WebData.Test/MockDatabase.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace WebMatrix.WebData.Test
+{
+    public abstract class MockDatabase : IDatabase
+    {
+        public abstract dynamic QuerySingle(string commandText, params object[] args);
+
+        public abstract IEnumerable<dynamic> Query(string commandText, params object[] parameters);
+
+        public abstract dynamic QueryValue(string commandText, params object[] parameters);
+
+        public abstract int Execute(string commandText, params object[] args);
+
+        public void Dispose()
+        {
+            // Do nothing.
+        }
+    }
+}

external/aspnetwebstack/test/WebMatrix.WebData.Test/PreApplicationStartCodeTest.cs

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Configuration;
+using System.Linq;
+using System.Reflection;
+using System.Web.Security;
+using System.Web.WebPages.Razor;
+using System.Web.WebPages.TestUtils;
+using Xunit;
+
+namespace WebMatrix.WebData.Test
+{
+    public class PreApplicationStartCodeTest
+    {
+        [Fact]
+        public void StartRegistersRazorNamespaces()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                AppDomainUtils.SetPreAppStartStage();
+                PreApplicationStartCode.Start();
+                // Call a second time to ensure multiple calls do not cause issues
+                PreApplicationStartCode.Start();
+
+                // Verify namespaces
+                var imports = WebPageRazorHost.GetGlobalImports();
+                Assert.True(imports.Any(ns => ns.Equals("WebMatrix.Data")));
+                Assert.True(imports.Any(ns => ns.Equals("WebMatrix.WebData")));
+            });
+        }
+
+        [Fact]
+        public void StartInitializesFormsAuthByDefault()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                AppDomainUtils.SetPreAppStartStage();
+                PreApplicationStartCode.Start();
+
+                string formsAuthLoginUrl = (string)typeof(FormsAuthentication).GetField("_LoginUrl", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
+                Assert.Equal(FormsAuthenticationSettings.DefaultLoginUrl, formsAuthLoginUrl);
+            });
+        }
+
+        [Fact]
+        public void StartDoesNotInitializeFormsAuthWhenDisabled()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                AppDomainUtils.SetPreAppStartStage();
+                ConfigurationManager.AppSettings[WebSecurity.EnableSimpleMembershipKey] = "False";
+                PreApplicationStartCode.Start();
+
+                string formsAuthLoginUrl = (string)typeof(FormsAuthentication).GetField("_LoginUrl", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
+                Assert.Null(formsAuthLoginUrl);
+            });
+        }
+
+        [Fact]
+        public void StartInitializesSimpleMembershipByDefault()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                AppDomainUtils.SetPreAppStartStage();
+                PreApplicationStartCode.Start();
+
+                // Verify simple membership
+                var providers = Membership.Providers;
+                Assert.Equal(1, providers.Count);
+                foreach (var provider in providers)
+                {
+                    Assert.IsAssignableFrom<SimpleMembershipProvider>(provider);
+                }
+                Assert.True(Roles.Enabled);
+            });
+        }
+
+        [Fact]
+        public void StartDoesNotInitializeSimpleMembershipWhenDisabled()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                AppDomainUtils.SetPreAppStartStage();
+                ConfigurationManager.AppSettings[WebSecurity.EnableSimpleMembershipKey] = "False";
+                PreApplicationStartCode.Start();
+
+                // Verify simple membership
+                var providers = Membership.Providers;
+                Assert.Equal(1, providers.Count);
+                foreach (var provider in providers)
+                {
+                    Assert.IsAssignableFrom<SqlMembershipProvider>(provider);
+                }
+                Assert.False(Roles.Enabled);
+            });
+        }
+
+        [Fact]
+        public void TestPreAppStartClass()
+        {
+            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
+        }
+    }
+}

external/aspnetwebstack/test/WebMatrix.WebData.Test/Properties/AssemblyInfo.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Reflection;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("WebMatrix.WebData.Test")]
+[assembly: AssemblyDescription("")]

external/aspnetwebstack/test/WebMatrix.WebData.Test/SimpleMembershipProviderTest.cs

@@ -0,0 +1,201 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Data;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using Moq;
+using WebMatrix.Data;
+using Xunit;
+
+namespace WebMatrix.WebData.Test
+{
+    public class SimpleMembershipProviderTest
+    {
+        [Fact]
+        public void ConfirmAccountReturnsFalseIfNoRecordExistsForToken()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
+                .Returns(Enumerable.Empty<DynamicRecord>());
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("foo");
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void ConfirmAccountReturnsFalseIfConfirmationTokenDoesNotMatchInCase()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord record = GetRecord(98, "Foo");
+            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
+                .Returns(new[] { record });
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("foo");
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void ConfirmAccountReturnsFalseIfNoConfirmationTokenFromMultipleListMatchesInCase()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord recordA = GetRecord(98, "Foo");
+            DynamicRecord recordB = GetRecord(99, "fOo");
+            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
+                .Returns(new[] { recordA, recordB });
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("foo");
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void ConfirmAccountUpdatesIsConfirmedFieldIfConfirmationTokenMatches()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord record = GetRecord(100, "foo");
+            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
+                .Returns(new[] { record }).Verifiable();
+            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 100)).Returns(1).Verifiable();
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("foo");
+
+            // Assert
+            Assert.True(result);
+            database.Verify();
+        }
+
+        [Fact]
+        public void ConfirmAccountUpdatesIsConfirmedFieldIfAnyOneOfReturnRecordConfirmationTokenMatches()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord recordA = GetRecord(100, "Foo");
+            DynamicRecord recordB = GetRecord(101, "foo");
+            DynamicRecord recordC = GetRecord(102, "fOo");
+            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
+                .Returns(new[] { recordA, recordB, recordC }).Verifiable();
+            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 101)).Returns(1).Verifiable();
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("foo");
+
+            // Assert
+            Assert.True(result);
+            database.Verify();
+        }
+
+        [Fact]
+        public void ConfirmAccountWithUserNameReturnsFalseIfNoRecordExistsForToken()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users] u ON m.[UserId] = u.[UserId] WHERE m.[ConfirmationToken] = @0 AND u.[UserName] = @1", "foo", "user12")).Returns(null);
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserIdColumn = "UserId", UserNameColumn = "UserName", UserTableName = "Users" };
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("user12", "foo");
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void ConfirmAccountWithUserNameReturnsFalseIfConfirmationTokenDoesNotMatchInCase()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord record = GetRecord(98, "Foo");
+            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users_bkp2_1] u ON m.[UserId] = u.[wishlist_site_real_user_id] WHERE m.[ConfirmationToken] = @0 AND u.[wishlist_site_real_user_name] = @1", "foo", "user13")).Returns(record);
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserIdColumn = "wishlist_site_real_user_id", UserNameColumn = "wishlist_site_real_user_name", UserTableName = "Users_bkp2_1" };
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("user13", "foo");
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void ConfirmAccountWithUserNameUpdatesIsConfirmedFieldIfConfirmationTokenMatches()
+        {
+            // Arrange
+            var database = new Mock<MockDatabase>(MockBehavior.Strict);
+            DynamicRecord record = GetRecord(100, "foo");
+            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users] u ON m.[UserId] = u.[Id] WHERE m.[ConfirmationToken] = @0 AND u.[UserName] = @1", "foo", "user14"))
+                .Returns(record).Verifiable();
+            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 100)).Returns(1).Verifiable();
+            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserTableName = "Users", UserIdColumn = "Id", UserNameColumn = "UserName" };
+
+            // Act
+            bool result = simpleMembershipProvider.ConfirmAccount("user14", "foo");
+
+            // Assert
+            Assert.True(result);
+            database.Verify();
+        }
+
+        [Fact]
+        public void GenerateTokenHtmlEncodesValues()
+        {
+            // Arrange
+            var generator = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
+            var generatedBytes = Encoding.Default.GetBytes("|aÿx§#½oÿ↨îA8Eµ");
+            generator.Setup(g => g.GetBytes(It.IsAny<byte[]>())).Callback((byte[] array) => Array.Copy(generatedBytes, array, generatedBytes.Length));
+
+            // Act
+            var result = SimpleMembershipProvider.GenerateToken(generator.Object);
+
+            // Assert
+            Assert.Equal("fGH/eKcjvW//P+5BOEW1", Convert.ToBase64String(generatedBytes));
+            Assert.Equal("fGH_eKcjvW__P-5BOEW1AA2", result);
+        }
+
+        private static DynamicRecord GetRecord(int userId, string confirmationToken)
+        {
+            var data = new Mock<IDataRecord>(MockBehavior.Strict);
+            data.Setup(c => c[0]).Returns(userId);
+            data.Setup(c => c[1]).Returns(confirmationToken);
+            return new DynamicRecord(new[] { "UserId", "ConfirmationToken" }, data.Object);
+        }
+
+        private class TestSimpleMembershipProvider : SimpleMembershipProvider
+        {
+            private readonly IDatabase _database;
+
+            public TestSimpleMembershipProvider(IDatabase database)
+            {
+                _database = database;
+            }
+
+            internal override IDatabase ConnectToDatabase()
+            {
+                return _database;
+            }
+
+            internal override void VerifyInitialized()
+            {
+                // Do nothing.
+            }
+        }
+    }
+}

external/aspnetwebstack/test/WebMatrix.WebData.Test/WebMatrix.WebData.Test.csproj

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{CD48EB41-92A5-4628-A0F7-6A43DF58827E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>WebMatrix.WebData.Test</RootNamespace>
+    <AssemblyName>WebMatrix.WebData.Test</AssemblyName>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\Debug\Test\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\Release\Test\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'CodeCoverage' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\CodeCoverage\Test\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Moq, Version=4.0.10827.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Moq.4.0.10827\lib\NET40\Moq.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.ApplicationServices" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="xunit">
+      <HintPath>..\..\packages\xunit.1.9.0.1566\lib\xunit.dll</HintPath>
+    </Reference>
+    <Reference Include="xunit.extensions">
+      <HintPath>..\..\packages\xunit.extensions.1.9.0.1566\lib\xunit.extensions.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="MockDatabase.cs" />
+    <Compile Include="PreApplicationStartCodeTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SimpleMembershipProviderTest.cs" />
+    <Compile Include="WebSecurityTest.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
+      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
+      <Name>System.Web.Razor</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
+      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
+      <Name>System.Web.WebPages.Razor</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\WebMatrix.Data\WebMatrix.Data.csproj">
+      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
+      <Name>WebMatrix.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\WebMatrix.WebData\WebMatrix.WebData.csproj">
+      <Project>{55A15F40-1435-4248-A7F2-2A146BB83586}</Project>
+      <Name>WebMatrix.WebData</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
+      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
+      <Name>Microsoft.TestCommon</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+</Project>

external/aspnetwebstack/test/WebMatrix.WebData.Test/WebSecurityTest.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace WebMatrix.WebData.Test
+{
+    public class WebSecurityTest
+    {
+        [Fact]
+        public void VerifyExtendedMembershipProviderMethodsThrowWithInvalidProvider()
+        {
+            const string errorString = "To call this method, the \"Membership.Provider\" property must be an instance of \"ExtendedMembershipProvider\".";
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.ConfirmAccount(""), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GeneratePasswordResetToken(""), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetUserIdFromPasswordResetToken(""), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.ResetPassword("", "whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.CreateUserAndAccount("", "whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.CreateAccount("", "whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.IsConfirmed("whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetPasswordFailuresSinceLastSuccess("whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetCreateDate("whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetLastPasswordFailureDate("whatever"), errorString);
+            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetPasswordChangedDate("whatever"), errorString);
+        }
+    }
+}

external/aspnetwebstack/test/WebMatrix.WebData.Test/packages.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Moq" version="4.0.10827" />
+  <package id="xunit" version="1.9.0.1566" />
+  <package id="xunit.extensions" version="1.9.0.1566" />
+</packages>