Run formatting (#2230)

2025-07-01 08:02:49 -05:00 · 2022-08-29 16:06:55 -04:00
parent 9b7aef0763
commit 7f5f010e1e
1205 changed files with 73813 additions and 75022 deletions
--- a/test/Core.Test/Tokens/DataProtectorTokenFactoryTests.cs
+++ b/test/Core.Test/Tokens/DataProtectorTokenFactoryTests.cs
@ -7,122 +7,121 @@ using Bit.Test.Common.Helpers;
 using Microsoft.AspNetCore.DataProtection;
 using Xunit;

-namespace Bit.Core.Test.Tokens
+namespace Bit.Core.Test.Tokens;
+
+[SutProviderCustomize]
+public class DataProtectorTokenFactoryTests
 {
-    [SutProviderCustomize]
-    public class DataProtectorTokenFactoryTests
+    public static SutProvider<DataProtectorTokenFactory<TestTokenable>> GetSutProvider()
    {
-        public static SutProvider<DataProtectorTokenFactory<TestTokenable>> GetSutProvider()
-        {
-            var fixture = new Fixture();
-            return new SutProvider<DataProtectorTokenFactory<TestTokenable>>(fixture)
-                .SetDependency<IDataProtectionProvider>(fixture.Create<EphemeralDataProtectionProvider>())
-                .Create();
-        }
-
-        [Theory, BitAutoData]
-        public void CanRoundTripTokenables(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-
-            var token = sutProvider.Sut.Protect(tokenable);
-            var recoveredTokenable = sutProvider.Sut.Unprotect(token);
-
-            AssertHelper.AssertPropertyEqual(tokenable, recoveredTokenable);
-        }
-
-        [Theory, BitAutoData]
-        public void PrependsClearText(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-
-            var token = sutProvider.Sut.Protect(tokenable);
-
-            Assert.StartsWith(sutProvider.GetDependency<string>("clearTextPrefix"), token);
-        }
-
-        [Theory, BitAutoData]
-        public void EncryptsToken(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-            var prefix = sutProvider.GetDependency<string>("clearTextPrefix");
-
-            var token = sutProvider.Sut.Protect(tokenable);
-
-            Assert.NotEqual(new Token(token).RemovePrefix(prefix), tokenable.ToToken());
-        }
-
-        [Theory, BitAutoData]
-        public void ThrowsIfUnprotectFails(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-
-            var token = sutProvider.Sut.Protect(tokenable);
-            token += "stuff to make sure decryption fails";
-
-            Assert.Throws<CryptographicException>(() => sutProvider.Sut.Unprotect(token));
-        }
-
-        [Theory, BitAutoData]
-        public void TryUnprotect_FalseIfUnprotectFails(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-            var token = sutProvider.Sut.Protect(tokenable) + "fail decryption";
-
-            var result = sutProvider.Sut.TryUnprotect(token, out var data);
-
-            Assert.False(result);
-            Assert.Null(data);
-        }
-
-        [Theory, BitAutoData]
-        public void TokenValid_FalseIfUnprotectFails(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-            var token = sutProvider.Sut.Protect(tokenable) + "fail decryption";
-
-            var result = sutProvider.Sut.TokenValid(token);
-
-            Assert.False(result);
-        }
-
-
-        [Theory, BitAutoData]
-        public void TokenValid_FalseIfTokenInvalid(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-
-            tokenable.ForceInvalid = true;
-            var token = sutProvider.Sut.Protect(tokenable);
-
-            var result = sutProvider.Sut.TokenValid(token);
-
-            Assert.False(result);
-        }
-
-        [Theory, BitAutoData]
-        public void TryUnprotect_TrueIfSuccess(TestTokenable tokenable)
-        {
-            var sutProvider = GetSutProvider();
-            var token = sutProvider.Sut.Protect(tokenable);
-
-            var result = sutProvider.Sut.TryUnprotect(token, out var data);
-
-            Assert.True(result);
-            AssertHelper.AssertPropertyEqual(tokenable, data);
-        }
-
-        [Theory, BitAutoData]
-        public void TokenValid_TrueIfSuccess(TestTokenable tokenable)
-        {
-            tokenable.ForceInvalid = false;
-            var sutProvider = GetSutProvider();
-            var token = sutProvider.Sut.Protect(tokenable);
-
-            var result = sutProvider.Sut.TokenValid(token);
-
-            Assert.True(result);
-        }
-
+        var fixture = new Fixture();
+        return new SutProvider<DataProtectorTokenFactory<TestTokenable>>(fixture)
+            .SetDependency<IDataProtectionProvider>(fixture.Create<EphemeralDataProtectionProvider>())
+            .Create();
    }
+
+    [Theory, BitAutoData]
+    public void CanRoundTripTokenables(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+
+        var token = sutProvider.Sut.Protect(tokenable);
+        var recoveredTokenable = sutProvider.Sut.Unprotect(token);
+
+        AssertHelper.AssertPropertyEqual(tokenable, recoveredTokenable);
+    }
+
+    [Theory, BitAutoData]
+    public void PrependsClearText(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+
+        var token = sutProvider.Sut.Protect(tokenable);
+
+        Assert.StartsWith(sutProvider.GetDependency<string>("clearTextPrefix"), token);
+    }
+
+    [Theory, BitAutoData]
+    public void EncryptsToken(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+        var prefix = sutProvider.GetDependency<string>("clearTextPrefix");
+
+        var token = sutProvider.Sut.Protect(tokenable);
+
+        Assert.NotEqual(new Token(token).RemovePrefix(prefix), tokenable.ToToken());
+    }
+
+    [Theory, BitAutoData]
+    public void ThrowsIfUnprotectFails(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+
+        var token = sutProvider.Sut.Protect(tokenable);
+        token += "stuff to make sure decryption fails";
+
+        Assert.Throws<CryptographicException>(() => sutProvider.Sut.Unprotect(token));
+    }
+
+    [Theory, BitAutoData]
+    public void TryUnprotect_FalseIfUnprotectFails(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+        var token = sutProvider.Sut.Protect(tokenable) + "fail decryption";
+
+        var result = sutProvider.Sut.TryUnprotect(token, out var data);
+
+        Assert.False(result);
+        Assert.Null(data);
+    }
+
+    [Theory, BitAutoData]
+    public void TokenValid_FalseIfUnprotectFails(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+        var token = sutProvider.Sut.Protect(tokenable) + "fail decryption";
+
+        var result = sutProvider.Sut.TokenValid(token);
+
+        Assert.False(result);
+    }
+
+
+    [Theory, BitAutoData]
+    public void TokenValid_FalseIfTokenInvalid(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+
+        tokenable.ForceInvalid = true;
+        var token = sutProvider.Sut.Protect(tokenable);
+
+        var result = sutProvider.Sut.TokenValid(token);
+
+        Assert.False(result);
+    }
+
+    [Theory, BitAutoData]
+    public void TryUnprotect_TrueIfSuccess(TestTokenable tokenable)
+    {
+        var sutProvider = GetSutProvider();
+        var token = sutProvider.Sut.Protect(tokenable);
+
+        var result = sutProvider.Sut.TryUnprotect(token, out var data);
+
+        Assert.True(result);
+        AssertHelper.AssertPropertyEqual(tokenable, data);
+    }
+
+    [Theory, BitAutoData]
+    public void TokenValid_TrueIfSuccess(TestTokenable tokenable)
+    {
+        tokenable.ForceInvalid = false;
+        var sutProvider = GetSutProvider();
+        var token = sutProvider.Sut.Protect(tokenable);
+
+        var result = sutProvider.Sut.TokenValid(token);
+
+        Assert.True(result);
+    }
+
 }
--- a/test/Core.Test/Tokens/ExpiringTokenTests.cs
+++ b/test/Core.Test/Tokens/ExpiringTokenTests.cs
@ -3,69 +3,68 @@ using AutoFixture.Xunit2;
 using Bit.Core.Utilities;
 using Xunit;

-namespace Bit.Core.Test.Tokens
+namespace Bit.Core.Test.Tokens;
+
+public class ExpiringTokenTests
 {
-    public class ExpiringTokenTests
+    [Theory, AutoData]
+    public void ExpirationSerializesToEpochMilliseconds(DateTime expirationDate)
    {
-        [Theory, AutoData]
-        public void ExpirationSerializesToEpochMilliseconds(DateTime expirationDate)
+        var sut = new TestExpiringTokenable
        {
-            var sut = new TestExpiringTokenable
-            {
-                ExpirationDate = expirationDate
-            };
+            ExpirationDate = expirationDate
+        };

-            var result = JsonSerializer.Serialize(sut);
-            var expectedDate = CoreHelpers.ToEpocMilliseconds(expirationDate);
+        var result = JsonSerializer.Serialize(sut);
+        var expectedDate = CoreHelpers.ToEpocMilliseconds(expirationDate);

-            Assert.Contains($"\"ExpirationDate\":{expectedDate}", result);
-        }
+        Assert.Contains($"\"ExpirationDate\":{expectedDate}", result);
+    }

-        [Theory, AutoData]
-        public void ExpirationSerializationRoundTrip(DateTime expirationDate)
+    [Theory, AutoData]
+    public void ExpirationSerializationRoundTrip(DateTime expirationDate)
+    {
+        var sut = new TestExpiringTokenable
        {
-            var sut = new TestExpiringTokenable
-            {
-                ExpirationDate = expirationDate
-            };
+            ExpirationDate = expirationDate
+        };

-            var intermediate = JsonSerializer.Serialize(sut);
-            var result = JsonSerializer.Deserialize<TestExpiringTokenable>(intermediate);
+        var intermediate = JsonSerializer.Serialize(sut);
+        var result = JsonSerializer.Deserialize<TestExpiringTokenable>(intermediate);

-            Assert.Equal(sut.ExpirationDate, result.ExpirationDate, TimeSpan.FromMilliseconds(100));
-        }
+        Assert.Equal(sut.ExpirationDate, result.ExpirationDate, TimeSpan.FromMilliseconds(100));
+    }

-        [Fact]
-        public void InvalidIfPastExpiryDate()
+    [Fact]
+    public void InvalidIfPastExpiryDate()
+    {
+        var sut = new TestExpiringTokenable
        {
-            var sut = new TestExpiringTokenable
-            {
-                ExpirationDate = DateTime.UtcNow.AddHours(-1)
-            };
+            ExpirationDate = DateTime.UtcNow.AddHours(-1)
+        };

-            Assert.False(sut.Valid);
-        }
+        Assert.False(sut.Valid);
+    }

-        [Fact]
-        public void ValidIfWithinExpirationAndTokenReportsValid()
+    [Fact]
+    public void ValidIfWithinExpirationAndTokenReportsValid()
+    {
+        var sut = new TestExpiringTokenable
        {
-            var sut = new TestExpiringTokenable
-            {
-                ExpirationDate = DateTime.UtcNow.AddHours(1)
-            };
+            ExpirationDate = DateTime.UtcNow.AddHours(1)
+        };

-            Assert.True(sut.Valid);
-        }
+        Assert.True(sut.Valid);
+    }

-        [Fact]
-        public void HonorsTokenIsValidAbstractMember()
+    [Fact]
+    public void HonorsTokenIsValidAbstractMember()
+    {
+        var sut = new TestExpiringTokenable(forceInvalid: true)
        {
-            var sut = new TestExpiringTokenable(forceInvalid: true)
-            {
-                ExpirationDate = DateTime.UtcNow.AddHours(1)
-            };
+            ExpirationDate = DateTime.UtcNow.AddHours(1)
+        };

-            Assert.False(sut.Valid);
-        }
+        Assert.False(sut.Valid);
    }
 }
--- a/test/Core.Test/Tokens/TestTokenable.cs
+++ b/test/Core.Test/Tokens/TestTokenable.cs
@ -1,26 +1,25 @@
 using System.Text.Json.Serialization;
 using Bit.Core.Tokens;

-namespace Bit.Core.Test.Tokens
+namespace Bit.Core.Test.Tokens;
+
+public class TestTokenable : Tokenable
 {
-    public class TestTokenable : Tokenable
-    {
-        public bool ForceInvalid { get; set; } = false;
+    public bool ForceInvalid { get; set; } = false;

-        [JsonIgnore]
-        public override bool Valid => !ForceInvalid;
-    }
-
-    public class TestExpiringTokenable : ExpiringTokenable
-    {
-        private bool _forceInvalid;
-
-        public TestExpiringTokenable() : this(false) { }
-
-        public TestExpiringTokenable(bool forceInvalid)
-        {
-            _forceInvalid = forceInvalid;
-        }
-        protected override bool TokenIsValid() => !_forceInvalid;
-    }
+    [JsonIgnore]
+    public override bool Valid => !ForceInvalid;
+}
+
+public class TestExpiringTokenable : ExpiringTokenable
+{
+    private bool _forceInvalid;
+
+    public TestExpiringTokenable() : this(false) { }
+
+    public TestExpiringTokenable(bool forceInvalid)
+    {
+        _forceInvalid = forceInvalid;
+    }
+    protected override bool TokenIsValid() => !_forceInvalid;
 }
--- a/test/Core.Test/Tokens/TokenTests.cs
+++ b/test/Core.Test/Tokens/TokenTests.cs
@ -2,38 +2,37 @@
 using Bit.Core.Tokens;
 using Xunit;

-namespace Bit.Core.Test.Tokens
+namespace Bit.Core.Test.Tokens;
+
+public class TokenTests
 {
-    public class TokenTests
+    [Theory, AutoData]
+    public void InitializeWithString_ReturnsString(string initString)
    {
-        [Theory, AutoData]
-        public void InitializeWithString_ReturnsString(string initString)
-        {
-            var token = new Token(initString);
+        var token = new Token(initString);

-            Assert.Equal(initString, token.ToString());
-        }
+        Assert.Equal(initString, token.ToString());
+    }

-        [Theory, AutoData]
-        public void AddsPrefix(Token token, string prefix)
-        {
-            Assert.Equal($"{prefix}{token.ToString()}", token.WithPrefix(prefix).ToString());
-        }
+    [Theory, AutoData]
+    public void AddsPrefix(Token token, string prefix)
+    {
+        Assert.Equal($"{prefix}{token.ToString()}", token.WithPrefix(prefix).ToString());
+    }

-        [Theory, AutoData]
-        public void RemovePrefix_WithPrefix_RemovesPrefix(string initString, string prefix)
-        {
-            var token = new Token(initString).WithPrefix(prefix);
+    [Theory, AutoData]
+    public void RemovePrefix_WithPrefix_RemovesPrefix(string initString, string prefix)
+    {
+        var token = new Token(initString).WithPrefix(prefix);

-            Assert.Equal(initString, token.RemovePrefix(prefix).ToString());
-        }
+        Assert.Equal(initString, token.RemovePrefix(prefix).ToString());
+    }

-        [Theory, AutoData]
-        public void RemovePrefix_WithoutPrefix_Throws(Token token, string prefix)
-        {
-            var exception = Assert.Throws<BadTokenException>(() => token.RemovePrefix(prefix));
+    [Theory, AutoData]
+    public void RemovePrefix_WithoutPrefix_Throws(Token token, string prefix)
+    {
+        var exception = Assert.Throws<BadTokenException>(() => token.RemovePrefix(prefix));

-            Assert.Equal($"Expected prefix, {prefix}, was not present.", exception.Message);
-        }
+        Assert.Equal($"Expected prefix, {prefix}, was not present.", exception.Message);
    }
 }