diff --git a/src/Core/Utilities/CoreHelpers.cs b/src/Core/Utilities/CoreHelpers.cs index f00c9a7e8..3c2f35eea 100644 --- a/src/Core/Utilities/CoreHelpers.cs +++ b/src/Core/Utilities/CoreHelpers.cs @@ -349,7 +349,7 @@ namespace Bit.Core.Utilities } else { - return absoluteSize.ToString("0 Bytes"); // Byte + return size.ToString("0 Bytes"); // Byte } // Divide by 1024 to get fractional value diff --git a/test/Core.Test/IdentityServer/TokenRetrievalTests.cs b/test/Core.Test/IdentityServer/TokenRetrievalTests.cs index 1375ff166..0c70153f5 100644 --- a/test/Core.Test/IdentityServer/TokenRetrievalTests.cs +++ b/test/Core.Test/IdentityServer/TokenRetrievalTests.cs @@ -1,16 +1,16 @@ using System; -using Microsoft.AspNetCore.Http; -using Bit.Core.IdentityServer; -using Xunit; -using NSubstitute; using System.Collections.Generic; +using Bit.Core.IdentityServer; +using Microsoft.AspNetCore.Http; using Microsoft.Extensions.Primitives; +using NSubstitute; +using Xunit; namespace Bit.Core.Test.IdentityServer { public class TokenRetrievalTests { - private Func Retrieve = TokenRetrieval.FromAuthorizationHeaderOrQueryString(); + private readonly Func _sut = TokenRetrieval.FromAuthorizationHeaderOrQueryString(); [Fact] public void RetrieveToken_FromHeader_ReturnsToken() @@ -27,7 +27,7 @@ namespace Bit.Core.Test.IdentityServer request.Headers.Returns(headers); // Act - var token = Retrieve(request); + var token = _sut(request); // Assert Assert.Equal("test_value", token); @@ -47,7 +47,7 @@ namespace Bit.Core.Test.IdentityServer request.Query.Returns(new QueryCollection(queryString)); // Act - var token = Retrieve(request); + var token = _sut(request); // Assert Assert.Equal("test_value", token); @@ -74,7 +74,7 @@ namespace Bit.Core.Test.IdentityServer request.Query.Returns(new QueryCollection(queryString)); // Act - var token = Retrieve(request); + var token = _sut(request); // Assert Assert.Equal("header_token", token); @@ -87,7 +87,7 @@ namespace Bit.Core.Test.IdentityServer var request = Substitute.For(); // Act - var token = Retrieve(request); + var token = _sut(request); // Assert Assert.Null(token); diff --git a/test/Core.Test/Utilities/CoreHelpersTests.cs b/test/Core.Test/Utilities/CoreHelpersTests.cs new file mode 100644 index 000000000..c3f203a9c --- /dev/null +++ b/test/Core.Test/Utilities/CoreHelpersTests.cs @@ -0,0 +1,220 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Bit.Core.Utilities; +using Xunit; + +namespace Bit.Core.Test.Utilities +{ + public class CoreHelpersTests + { + public static IEnumerable _epochTestCases = new[] + { + new object[] {new DateTime(2020, 12, 30, 11, 49, 12, DateTimeKind.Utc), 1609328952000L}, + }; + + [Fact] + public void GenerateComb_Success() + { + // Arrange & Act + var comb = CoreHelpers.GenerateComb(); + + // Assert + Assert.NotEqual(Guid.Empty, comb); + // TODO: Add more asserts to make sure important aspects of + // the comb are working properly + } + + [Theory] + [InlineData(2, 5, new[] { 1, 2, 3, 4, 5, 6, 7, 8 , 9, 0 })] + [InlineData(2, 3, new[] { 1, 2, 3, 4, 5 })] + [InlineData(2, 1, new[] { 1, 2 })] + [InlineData(1, 1, new[] { 1 })] + [InlineData(2, 2, new[] { 1, 2, 3 })] + public void Batch_Success(int batchSize, int totalBatches, int[] collection) + { + // Arrange + var remainder = collection.Length % batchSize; + + // Act + var batches = collection.Batch(batchSize); + + // Assert + Assert.Equal(totalBatches, batches.Count()); + + foreach (var batch in batches.Take(totalBatches - 1)) + { + Assert.Equal(batchSize, batch.Count()); + } + + Assert.Equal(batches.Last().Count(), remainder == 0 ? batchSize : remainder); + } + + [Fact] + public void ToGuidIdArrayTVP_Success() + { + // Arrange + var item0 = Guid.NewGuid(); + var item1 = Guid.NewGuid(); + + var ids = new[] { item0, item1 }; + + // Act + var dt = ids.ToGuidIdArrayTVP(); + + // Assert + Assert.Single(dt.Columns); + Assert.Equal("GuidId", dt.Columns[0].ColumnName); + Assert.Equal(2, dt.Rows.Count); + Assert.Equal(item0, dt.Rows[0][0]); + Assert.Equal(item1, dt.Rows[1][0]); + } + + // TODO: Test the other ToArrayTVP Methods + + [Theory] + [InlineData("12345&6789", "123456789")] + [InlineData("abcdef", "ABCDEF")] + [InlineData("1!@#$%&*()_+", "1")] + [InlineData("\u00C6123abc\u00C7", "123ABC")] + [InlineData("123\u00C6ABC", "123ABC")] + [InlineData("\r\nHello", "E")] + [InlineData("\tdef", "DEF")] + [InlineData("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV1234567890", "ABCDEFABCDEF1234567890")] + public void CleanCertificateThumbprint_Success(string input, string output) + { + // Arrange & Act + var sanitizedInput = CoreHelpers.CleanCertificateThumbprint(input); + + // Assert + Assert.Equal(output, sanitizedInput); + } + + // TODO: Add more tests + [Theory] + [MemberData(nameof(_epochTestCases))] + public void ToEpocMilliseconds_Success(DateTime date, long milliseconds) + { + // Act & Assert + Assert.Equal(milliseconds, CoreHelpers.ToEpocMilliseconds(date)); + } + + [Theory] + [MemberData(nameof(_epochTestCases))] + public void FromEpocMilliseconds(DateTime date, long milliseconds) + { + // Act & Assert + Assert.Equal(date, CoreHelpers.FromEpocMilliseconds(milliseconds)); + } + + [Fact] + public void SecureRandomString_Success() + { + // Arrange & Act + var @string = CoreHelpers.SecureRandomString(8); + + // Assert + // TODO: Should probably add more Asserts down the line + Assert.Equal(8, @string.Length); + } + + [Theory] + [InlineData(1, "1 Bytes")] + [InlineData(-5L, "-5 Bytes")] + [InlineData(1023L, "1023 Bytes")] + [InlineData(1024L, "1 KB")] + [InlineData(1025L, "1 KB")] + [InlineData(-1023L, "-1023 Bytes")] + [InlineData(-1024L, "-1 KB")] + [InlineData(-1025L, "-1 KB")] + [InlineData(1048575L, "1024 KB")] + [InlineData(1048576L, "1 MB")] + [InlineData(1048577L, "1 MB")] + [InlineData(-1048575L, "-1024 KB")] + [InlineData(-1048576L, "-1 MB")] + [InlineData(-1048577L, "-1 MB")] + [InlineData(1073741823L, "1024 MB")] + [InlineData(1073741824L, "1 GB")] + [InlineData(1073741825L, "1 GB")] + [InlineData(-1073741823L, "-1024 MB")] + [InlineData(-1073741824L, "-1 GB")] + [InlineData(-1073741825L, "-1 GB")] + [InlineData(long.MaxValue, "8589934592 GB")] + public void ReadableBytesSize_Success(long size, string readable) + { + // Act & Assert + Assert.Equal(readable, CoreHelpers.ReadableBytesSize(size)); + } + + [Fact] + public void CloneObject_Success() + { + var orignial = new { Message = "Message" }; + + var copy = CoreHelpers.CloneObject(orignial); + + Assert.Equal(orignial.Message, copy.Message); + } + + [Fact] + public void ExtendQuery_AddNewParameter_Success() + { + // Arrange + var uri = new Uri("https://bitwarden.com/?param1=value1"); + + // Act + var newUri = CoreHelpers.ExtendQuery(uri, + new Dictionary { { "param2", "value2" } }); + + // Assert + Assert.Equal("https://bitwarden.com/?param1=value1¶m2=value2", newUri.ToString()); + } + + [Fact] + public void ExtendQuery_AddTwoNewParameters_Success() + { + // Arrange + var uri = new Uri("https://bitwarden.com/?param1=value1"); + + // Act + var newUri = CoreHelpers.ExtendQuery(uri, + new Dictionary + { + { "param2", "value2" }, + { "param3", "value3" } + }); + + // Assert + Assert.Equal("https://bitwarden.com/?param1=value1¶m2=value2¶m3=value3", newUri.ToString()); + } + + [Fact] + public void ExtendQuery_AddExistingParameter_Success() + { + // Arrange + var uri = new Uri("https://bitwarden.com/?param1=value1¶m2=value2"); + + // Act + var newUri = CoreHelpers.ExtendQuery(uri, + new Dictionary { { "param1", "test_value" } }); + + // Assert + Assert.Equal("https://bitwarden.com/?param1=test_value¶m2=value2", newUri.ToString()); + } + + [Fact] + public void ExtendQuery_AddNoParameters_Success() + { + // Arrange + const string startingUri = "https://bitwarden.com/?param1=value1"; + + var uri = new Uri(startingUri); + + // Act + var newUri = CoreHelpers.ExtendQuery(uri, new Dictionary()); + + // Assert + Assert.Equal(startingUri, newUri.ToString()); + } + } +} diff --git a/test/Core.Test/Utilities/SelfHostedAttributeTests.cs b/test/Core.Test/Utilities/SelfHostedAttributeTests.cs index 28e8b0264..d9c3b469c 100644 --- a/test/Core.Test/Utilities/SelfHostedAttributeTests.cs +++ b/test/Core.Test/Utilities/SelfHostedAttributeTests.cs @@ -1,15 +1,14 @@ - -using Bit.Core.Utilities; +using System.Collections.Generic; using Bit.Core.Exceptions; +using Bit.Core.Utilities; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.Abstractions; using Microsoft.AspNetCore.Mvc.Filters; +using Microsoft.AspNetCore.Routing; using Microsoft.Extensions.DependencyInjection; using NSubstitute; using Xunit; -using System.Collections.Generic; -using Microsoft.AspNetCore.Mvc; -using Microsoft.AspNetCore.Http; -using Microsoft.AspNetCore.Routing; -using Microsoft.AspNetCore.Mvc.Abstractions; namespace Bit.Core.Test.Utilities { @@ -18,33 +17,47 @@ namespace Bit.Core.Test.Utilities [Fact] public void NotSelfHosted_Throws_When_SelfHosted() { + // Arrange var sha = new SelfHostedAttribute { NotSelfHostedOnly = true }; + // Act & Assert Assert.Throws(() => sha.OnActionExecuting(GetContext(selfHosted: true))); } [Fact] public void NotSelfHosted_Success_When_NotSelfHosted() { + // Arrange var sha = new SelfHostedAttribute { NotSelfHostedOnly = true }; + // Act sha.OnActionExecuting(GetContext(selfHosted: false)); + + // Assert + // The Assert here is just NOT throwing an exception } [Fact] public void SelfHosted_Success_When_SelfHosted() { + // Arrange var sha = new SelfHostedAttribute { SelfHostedOnly = true }; + // Act sha.OnActionExecuting(GetContext(selfHosted: true)); + + // Assert + // The Assert here is just NOT throwing an exception } [Fact] public void SelfHosted_Throws_When_NotSelfHosted() { + // Arrange var sha = new SelfHostedAttribute { SelfHostedOnly = true }; + // Act & Assert Assert.Throws(() => sha.OnActionExecuting(GetContext(selfHosted: false))); }