Dev authorization fakes

CHANGELOG.md

@@ -9,6 +9,43 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ### Added
 List of new features.
 
+#### Authorization Fakes
+Added authentication/authorization fake services to make it easy to test Blazor components that use authorization either through code or the AuthorizeView component.
+You just need to call the AddAuthorization method on your TestContext.Services collection.
+
+First, define your component that uses AuthorizeView to render differently based on the user's authorization state.
+```
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
+
+<CascadingAuthenticationState>
+	<AuthorizeView>
+		<Authorized>
+			Authorized!
+		</Authorized>
+		<NotAuthorized>
+			Not authorized?
+		</NotAuthorized>
+	</AuthorizeView>
+</CascadingAuthenticationState>
+```
+Then, define your test method to specify the authorization state with a user name, and run your test.
+```c#
+[Fact(DisplayName = "AuthorizeView with authenticated and authorized user")]
+public void Test002()
+{
+	// arrange
+	using var ctx = new TestContext();
+	ctx.Services.AddAuthorization("TestUser", true);
+
+	// act
+	var cut = ctx.RenderComponent<SimpleAuthView>();
+
+	// assert
+	cut.MarkupMatches("Authorized!");
+}
+```
+
 ### Changed
 List of changes in existing functionality.
 

docs/site/docs/mocking/mocking-auth.md

@@ -1,8 +1,132 @@
----
+---
 uid: mocking-auth
 title: Mocking Blazor's Authorization
 ---
 
 # Mocking Blazor's Authorization
 
-https://github.com/egil/bunit/issues/135
+https://github.com/egil/bunit/issues/135
+
+When testing Blazor components that require authentication and authorization, you need to set up enough of the services and behavior to work with the Blazor AuthorizeView, CascadingAuthenticationState, and AuthorizeRouteView.
+
+You can use AuthorizeView in a component to show different content based on the user's authentication/authorization state. To set your component up for testing, you can do the following:
+
+```c#
+@using Microsoft.AspNetCore.Components.Authorization
+
+<CascadingAuthenticationState>
+	<AuthorizeView>
+		<Authorized>
+			Authorized!
+		</Authorized>
+		<NotAuthorized>
+			Not authorized?
+		</NotAuthorized>
+	</AuthorizeView>
+</CascadingAuthenticationState>
+```
+
+To easily test this type of component, bUnit has some test services that help. You will need to add these services to your test context before you render and run your tests.
+
+The following code tests the component with an unauthenticated user. To setup an authenticated user, just call AddAuthorization with no parameters.
+
+```c#
+[Fact(DisplayName = "AuthorizeView with unauthenticated user")]
+public void Test001()
+{
+	// arrange
+	using var ctx = new TestContext();
+	ctx.Services.AddAuthorization();
+
+	// act
+	var cut = ctx.RenderComponent<SimpleAuthView>();
+
+	// assert
+	cut.MarkupMatches("Not authorized?");
+}
+```
+
+Now we can test with an authenticated and authorized user by calling AddAuthorization with a user name and authorization flag.
+
+```c#
+[Fact(DisplayName = "AuthorizeView with authenticated and authorized user")]
+public void Test002()
+{
+	// arrange
+	using var ctx = new TestContext();
+	ctx.Services.AddAuthorization("TestUser", true);
+
+	// act
+	var cut = ctx.RenderComponent<SimpleAuthView>();
+
+	// assert
+	cut.MarkupMatches("Authorized!");
+}
+```
+
+Finally we can test with an authenticated and unauthorized user in the code below.
+
+```c#
+[Fact(DisplayName = "AuthorizeView with authenticated but unauthorized user")]
+public void Test003()
+{
+	// arrange
+	using var ctx = new TestContext();
+	ctx.Services.AddAuthorization("TestUser", false);
+
+	// act
+	var cut = ctx.RenderComponent<SimpleAuthView>();
+
+	// assert
+	cut.MarkupMatches("Not authorized?");
+}
+```
+
+In addition to using these services with AuthorizeView, you can also inject the services into your component and call them in your C# code. 
+
+```c#
+@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
+@inject AuthenticationStateProvider AuthenticationStateProvider
+
+<p>Test Component</p>
+
+@if (isAuthenticated)
+{
+    <p>User: @userName</p>
+}
+
+@code{
+    bool isAuthenticated = false;
+    string userName;
+
+    protected override async Task OnInitializedAsync()
+    {
+        var state = await AuthenticationStateProvider.GetAuthenticationStateAsync().ConfigureAwait(false);
+        if (state != null)
+        {
+            this.isAuthenticated = state.User.Identity.IsAuthenticated;
+            this.userName = state.User.Identity.Name;
+        }
+    }
+}
+```
+
+Then you can write a similar test as the ones above.
+
+```c#
+[Fact(DisplayName = "Use AuthenticationStateProvider service with authenticated and authorized user")]
+public void Test004()
+{
+	// arrange
+	using var ctx = new TestContext();
+	ctx.Services.AddAuthorization("TestUserName", true);
+
+	// act
+	var cut = ctx.RenderComponent<TestComponent>();
+
+	// assert
+	Assert.Contains("<p>User: TestUserName</p>", cut.Markup, StringComparison.InvariantCulture);
+}
+```
+
+That is all you need to support authorization and authentication testing in bUnit.

src/bunit.sln

@@ -46,7 +46,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{785D
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "bunit.template", "bunit.template\bunit.template.csproj", "{58FB9C26-7170-426C-ACE8-A98237710CDB}"
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "bunit.template", "bunit.template\bunit.template.csproj", "{56F7777C-38B1-4183-98A1-3D8D207A19BB}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -92,8 +91,6 @@ Global
 		{58FB9C26-7170-426C-ACE8-A98237710CDB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{58FB9C26-7170-426C-ACE8-A98237710CDB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{58FB9C26-7170-426C-ACE8-A98237710CDB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{56F7777C-38B1-4183-98A1-3D8D207A19BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{56F7777C-38B1-4183-98A1-3D8D207A19BB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/bunit.web.tests/TestDoubles/Authorization/FakeAuthenticationStateProviderTest.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Bunit.TestDoubles.Authorization
+{
+	public class FakeAuthenticationStateProviderTest
+	{
+		[Fact(DisplayName = "Create authenticated AuthenticationState")]
+		public async Task Test001()
+		{
+			// arrange
+			var roles = new List<string> { "User" };
+
+			// act
+			var authProvider = new FakeAuthenticationStateProvider("TestUser", roles);
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			// assert
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Equal("TestUser", authState.User.Identity.Name);
+			Assert.True(authState.User.Identity.IsAuthenticated);
+		}
+
+		[Fact(DisplayName = "Create unauthenticated AuthenticationState")]
+		public async Task Test002()
+		{
+			// act
+			var authProvider = new FakeAuthenticationStateProvider();
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			// assert
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Null(authState.User.Identity.Name);
+			Assert.False(authState.User.Identity.IsAuthenticated);
+		}
+
+		[Fact(DisplayName = "Switch AuthenticationState from unauthenticated to authenticated.")]
+		public async Task Test003()
+		{
+			// arrange
+			var authProvider = new FakeAuthenticationStateProvider();
+			var stateChangeHandled = false;
+			authProvider.AuthenticationStateChanged += e => stateChangeHandled = true;
+
+			var newState = FakeAuthenticationStateProvider.CreateAuthenticationState("NewUser");
+
+			// act
+			authProvider.TriggerAuthenticationStateChanged(newState);
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			// assert
+			Assert.True(stateChangeHandled);
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Equal("NewUser", authState.User.Identity.Name);
+			Assert.True(authState.User.Identity.IsAuthenticated);
+		}
+	}
+}

src/bunit.web.tests/TestDoubles/Authorization/FakeAuthorizationExtensionsTest.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Bunit.TestDoubles.Authorization
+{
+	public class FakeAuthorizationExtensionsTest
+	{
+		[Fact(DisplayName = "Register Authorization services with authenticated and authorized user.")]
+		public async Task Test001()
+		{
+			// arrange
+			using var sp = new TestServiceProvider();
+			var roles = new List<string> { "User" };
+			var principal = new ClaimsPrincipal(
+				new FakePrincipal { Identity = new FakeIdentity { Name = "DarthPedro" }, Roles = roles });
+
+			// act
+			sp.AddAuthorization("DarthPedro", true, roles);
+
+			var authProvider = sp.GetRequiredService<AuthenticationStateProvider>();
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			var authService = sp.GetRequiredService<IAuthorizationService>();
+			var authResult = await authService.AuthorizeAsync(principal, "testResource", "testPolicy");
+
+			// assert
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Equal("DarthPedro", authState.User.Identity.Name);
+			Assert.True(authState.User.Identity.IsAuthenticated);
+			Assert.True(authResult.Succeeded);
+		}
+
+		[Fact(DisplayName = "Register Authorization services with authenticated but unauthorized user.")]
+		public async Task Test002()
+		{
+			// arrange
+			using var sp = new TestServiceProvider();
+			var principal = new ClaimsPrincipal(
+				new FakePrincipal { Identity = new FakeIdentity { Name = "DarthPedro" } });
+
+			// act
+			sp.AddAuthorization("DarthPedro", false);
+
+			var authProvider = sp.GetRequiredService<AuthenticationStateProvider>();
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			var authService = sp.GetRequiredService<IAuthorizationService>();
+			var authResult = await authService.AuthorizeAsync(principal, "testResource", "testPolicy");
+
+			// assert
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Equal("DarthPedro", authState.User.Identity.Name);
+			Assert.True(authState.User.Identity.IsAuthenticated);
+			Assert.False(authResult.Succeeded);
+		}
+
+		[Fact(DisplayName = "Register Authorization services with unauthenticated user.")]
+		public async Task Test003()
+		{
+			// arrange
+			using var sp = new TestServiceProvider();
+			var principal = new ClaimsPrincipal(
+				new FakePrincipal { Identity = new FakeIdentity { Name = "DarthPedro" } });
+
+			// act
+			sp.AddAuthorization();
+
+			var authProvider = sp.GetRequiredService<AuthenticationStateProvider>();
+			var authState = await authProvider.GetAuthenticationStateAsync();
+
+			var authService = sp.GetRequiredService<IAuthorizationService>();
+			var authResult = await authService.AuthorizeAsync(principal, "testResource", "testPolicy");
+
+			// assert
+			Assert.NotNull(authState.User);
+			Assert.NotNull(authState.User.Identity);
+			Assert.Null(authState.User.Identity.Name);
+			Assert.False(authState.User.Identity.IsAuthenticated);
+			Assert.False(authResult.Succeeded);
+		}
+	}
+}