#283 Adding couple of tests for WithoutUser

Author: vaptsarov

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Authentication/BaseClaimsPrincipalUserBuilder.cs

@@ -25,6 +25,13 @@ public ClaimsPrincipal GetClaimsPrincipal()
             return claimsPrincipal;
         }
 
+        public ClaimsPrincipal GetClaimsPrincipalBasedOnClaimsOnly()
+        {
+            var claimsPrincipal = new ClaimsPrincipal(this.GetAuthenticatedClaimsIdentity());
+
+            return claimsPrincipal;
+        }
+
         /// <summary>
         /// Static constructor for creating default authenticated claims principal with "TestId" identifier and "TestUser" username.
         /// </summary>
@@ -37,5 +44,13 @@ protected void AddIdentity(ClaimsIdentity identity)
         {
             this._identities.Add(identity);
         }
+
+        protected void AddIdentities(IEnumerable<ClaimsIdentity> identities)
+        {
+            foreach (var identity in identities)
+            {
+                this.AddIdentity(identity);
+            }
+        }
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Authentication/BaseUserBuilder.cs

@@ -151,7 +151,7 @@ protected void RemoveClaim(Claim claim)
         protected void RemoveClaim(string type, string value)
         {
             var claimsToRemove =
-                this.claims.Where(x => x.Type.Equals(type) && x.Value.Equals(value));
+                this.claims.Where(x => x.Type.Equals(type) && x.Value.Equals(value)).ToList();
 
             claimsToRemove.ForEach(claim => this.claims.Remove(claim));
         }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Authentication/WithoutClaimsPrincipalBuilder.cs

@@ -5,6 +5,11 @@
 
     public class WithoutClaimsPrincipalBuilder : BaseClaimsPrincipalUserBuilder, IAndWithoutClaimsPrincipalBuilder
     {
+        public WithoutClaimsPrincipalBuilder(ClaimsPrincipal principal)
+        {
+            base.AddClaims(principal.Claims);
+        }
+
         public IAndWithoutClaimsPrincipalBuilder WithoutClaim(string type, string value)
         {
             base.RemoveClaim(type, value);
@@ -26,18 +31,6 @@ public IAndWithoutClaimsPrincipalBuilder WithoutRole(string role)
             return this;
         }
 
-        public IAndWithoutClaimsPrincipalBuilder WithoutUser()
-        {
-            return this;
-        }
-
-        public IAndWithoutClaimsPrincipalBuilder WithoutUsername(string username)
-        {
-            base.RemoveUsername(username);
-
-            return this;
-        }
-
         public IWithoutClaimsPrincipalBuilder AndAlso()
             => this;
     }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Contracts/Authentication/IWithoutClaimsPrincipalBuilder.cs

@@ -4,12 +4,8 @@
 
     public interface IWithoutClaimsPrincipalBuilder
     {
-        IAndWithoutClaimsPrincipalBuilder WithoutUser();
-
         IAndWithoutClaimsPrincipalBuilder WithoutRole(string role);
 
-        IAndWithoutClaimsPrincipalBuilder WithoutUsername(string username);
-
         IAndWithoutClaimsPrincipalBuilder WithoutClaim(string type, string value);
 
         IAndWithoutClaimsPrincipalBuilder WithoutClaim(Claim claim);

src/MyTested.AspNetCore.Mvc.Authentication/ComponentBuilderAuthenticationWithoutExtensions.cs

@@ -1,23 +1,42 @@
 namespace MyTested.AspNetCore.Mvc
 {
+    using System;
+    using System.Security.Claims;
     using MyTested.AspNetCore.Mvc.Builders.Authentication;
     using MyTested.AspNetCore.Mvc.Builders.Base;
     using MyTested.AspNetCore.Mvc.Builders.Contracts.Authentication;
     using MyTested.AspNetCore.Mvc.Builders.Contracts.Base;
-    using System;
 
     public static class ComponentBuilderAuthenticationWithoutExtensions
     {
+        public static TBuilder WithoutUser<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
+            string claimType, string value)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutUser(user => user.WithoutClaim(claimType, value));
+
+        public static TBuilder WithoutUser<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
+            Claim claim)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutUser(user => user.WithoutClaim(claim));
+
+        public static TBuilder WithoutUser<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
+            string role)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutUser(user => user.WithoutRole(role));
+
         public static TBuilder WithoutUser<TBuilder>(
             this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
             Action<IWithoutClaimsPrincipalBuilder> userBuilder)
             where TBuilder : IBaseTestBuilder
         {
             var actualBuilder = (BaseTestBuilderWithComponentBuilder<TBuilder>)builder;
 
-            var newUserBuilder = new WithoutClaimsPrincipalBuilder();
+            var newUserBuilder = new WithoutClaimsPrincipalBuilder(actualBuilder.HttpContext.User);
             userBuilder(newUserBuilder);
-            actualBuilder.HttpContext.User = newUserBuilder.GetClaimsPrincipal();
+            actualBuilder.HttpContext.User = newUserBuilder.GetClaimsPrincipalBasedOnClaimsOnly();
 
             return actualBuilder.Builder;
         }

test/MyTested.AspNetCore.Mvc.Authentication.Test/BuildersTests/AuthenticationTests/ClaimsPrincipalBuilderTests.cs

@@ -27,7 +27,7 @@ public void WithNameTypeShouldOverrideDefaultClaimType()
                     Assert.Equal("MyUsername", claim.Value);
                 });
         }
-        
+
         [Fact]
         public void WithRoleTypeShouldOverrideDefaultClaimType()
         {
@@ -69,7 +69,7 @@ public void WithIdentifierShouldSetCorrectIdentifier()
                     .WithIdentifier("TestingId"))
                 .ShouldPassForThe<MvcController>(controller =>
                 {
-                        var claim = controller.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
+                    var claim = controller.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
 
                     Assert.NotNull(claim);
                     Assert.Equal("TestingId", claim.Value);
@@ -126,7 +126,7 @@ public void WithClaimsShouldSetCorrectClaim()
                     Assert.Equal("MySecondValue", secondClaim.Value);
                 });
         }
-        
+
         [Fact]
         public void WithClaimsAsEnumerableShouldSetCorrectClaim()
         {
@@ -279,5 +279,55 @@ public void WithFullIdentityBuilderShouldSetProperClaims()
                     Assert.Contains("AnotherListRole", userRoleClaims);
                 });
         }
+
+        [Fact]
+        public void WithoutClaimShouldRemoveTheCorrectClaimOnly()
+        {
+            MyController<MvcController>
+                .Instance()
+                .WithUser(user => user
+                    .WithNameType("CustomUsername"))
+                .WithoutUser(user => user.WithoutClaim("CustomUsername", "TestUser"))
+                .ShouldPassForThe<MvcController>(controller =>
+                {
+                    var claimToBeDeleted = controller.User.Claims.FirstOrDefault(c => c.Type == "CustomUsername");
+
+                    Assert.Null(claimToBeDeleted);
+                });
+        }
+
+        [Fact(Skip = "Trying to find out why certain property is set.")]
+        public void WithoutClaimByProvidingClaimsDirectlyShouldRemoveTheCorrectClaimOnly()
+        { 
+            var claim = 
+                new Claim("CustomUsername", "TestUser", "string", "issuer","OGissuer", 
+                new ClaimsIdentity("Password", "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name", "http://schemas.microsoft.com/ws/2008/06/identity/claims/role"));
+
+            MyController<MvcController>
+                .Instance()
+                .WithUser(user => user.WithClaim(claim))
+                .WithoutUser(user => user.WithoutClaim(claim))
+                .ShouldPassForThe<MvcController>(controller =>
+                {
+                    var claimToBeDeleted = controller.User.Claims.FirstOrDefault(c => c.Type == claim.Type);
+
+                    Assert.Null(claimToBeDeleted);
+                });
+        }
+
+        [Fact]
+        public void WithoutRoleShouldRemoveTheCorrectRole()
+        {
+            MyController<MvcController>
+                .Instance()
+                .WithUser(user => user.InRole("randomRole"))
+                .WithoutUser(user => user.WithoutRole("randomRole"))
+                .ShouldPassForThe<MvcController>(controller =>
+                {
+                    var claimToBeDeleted = controller.User.Claims.FirstOrDefault(c => c.Type == "randomRole");
+
+                    Assert.Null(claimToBeDeleted);
+                });
+        }
     }
 }