Refactor Imaging Tests

framework/Volo.Abp.sln

@@ -447,7 +447,13 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.ImageSharp
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.MagickNet", "src\Volo.Abp.Imaging.MagickNet\Volo.Abp.Imaging.MagickNet.csproj", "{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.Tests", "test\Volo.Abp.Imaging.Tests\Volo.Abp.Imaging.Tests.csproj", "{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.Abstractions.Tests", "test\Volo.Abp.Imaging.Abstractions.Tests\Volo.Abp.Imaging.Abstractions.Tests.csproj", "{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.ImageSharp.Tests", "test\Volo.Abp.Imaging.ImageSharp.Tests\Volo.Abp.Imaging.ImageSharp.Tests.csproj", "{1E161A34-10C1-46FA-9EFD-10DD0858A8F5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.MagickNet.Tests", "test\Volo.Abp.Imaging.MagickNet.Tests\Volo.Abp.Imaging.MagickNet.Tests.csproj", "{62B2B8C9-8F24-4D31-894F-C1F0728D32AB}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.AspNetCore.Tests", "test\Volo.Abp.Imaging.AspNetCore.Tests\Volo.Abp.Imaging.AspNetCore.Tests.csproj", "{983B0136-384B-4439-B374-31111FFAA286}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -1339,6 +1345,18 @@ Global
 		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1E161A34-10C1-46FA-9EFD-10DD0858A8F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1E161A34-10C1-46FA-9EFD-10DD0858A8F5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1E161A34-10C1-46FA-9EFD-10DD0858A8F5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1E161A34-10C1-46FA-9EFD-10DD0858A8F5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{62B2B8C9-8F24-4D31-894F-C1F0728D32AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{62B2B8C9-8F24-4D31-894F-C1F0728D32AB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{62B2B8C9-8F24-4D31-894F-C1F0728D32AB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{62B2B8C9-8F24-4D31-894F-C1F0728D32AB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{983B0136-384B-4439-B374-31111FFAA286}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{983B0136-384B-4439-B374-31111FFAA286}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{983B0136-384B-4439-B374-31111FFAA286}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{983B0136-384B-4439-B374-31111FFAA286}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -1565,6 +1583,9 @@ Global
 		{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC} = {5DF0E140-0513-4D0D-BE2E-3D4D85CD70E6}
 		{78340A37-219E-4F2D-9AC6-40A7B467EEEC} = {5DF0E140-0513-4D0D-BE2E-3D4D85CD70E6}
 		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF} = {447C8A77-E5F0-4538-8687-7383196D04EA}
+		{1E161A34-10C1-46FA-9EFD-10DD0858A8F5} = {447C8A77-E5F0-4538-8687-7383196D04EA}
+		{62B2B8C9-8F24-4D31-894F-C1F0728D32AB} = {447C8A77-E5F0-4538-8687-7383196D04EA}
+		{983B0136-384B-4439-B374-31111FFAA286} = {447C8A77-E5F0-4538-8687-7383196D04EA}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {BB97ECF4-9A84-433F-A80B-2A3285BDD1D5}

framework/src/Volo.Abp.Imaging.AspNetCore/Volo/Abp/Imaging/CompressImageAttribute.cs

@@ -47,7 +47,7 @@ public class CompressImageAttribute : ActionFilterAttribute
     
     protected virtual async Task<IFormFile> CompressImageAsync(IFormFile file, IImageCompressor imageCompressor)
     {
-        if(file.ContentType == null || !file.ContentType.StartsWith("image/"))
+        if(file.Headers == null || file.ContentType == null || !file.ContentType.StartsWith("image/"))
         {
             return file;
         }

framework/src/Volo.Abp.Imaging.AspNetCore/Volo/Abp/Imaging/ResizeImageAttribute.cs

@@ -60,7 +60,7 @@ public class ResizeImageAttribute : ActionFilterAttribute
     
     protected virtual async Task<IFormFile> ResizeImageAsync(IFormFile file, IImageResizer imageResizer)
     {
-        if(file.ContentType == null || !file.ContentType.StartsWith("image/"))
+        if(file.Headers == null ||  file.ContentType == null || !file.ContentType.StartsWith("image/"))
         {
             return file;
         }

framework/test/Volo.Abp.Imaging.Tests/Volo.Abp.Imaging.Tests.csproj → framework/test/Volo.Abp.Imaging.Abstractions.Tests/Volo.Abp.Imaging.Abstractions.Tests.csproj

@@ -11,8 +11,6 @@
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
         <ProjectReference Include="..\..\src\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
         <ProjectReference Include="..\..\src\Volo.Abp.Imaging.Abstractions\Volo.Abp.Imaging.Abstractions.csproj" />
-        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.ImageSharp\Volo.Abp.Imaging.ImageSharp.csproj" />
-        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.MagickNet\Volo.Abp.Imaging.MagickNet.csproj" />
         <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
     </ItemGroup>
     

framework/test/Volo.Abp.Imaging.Abstractions.Tests/Volo/Abp/Imaging/AbpImagingAbstractionsTestBase.cs

@@ -0,0 +1,11 @@
+using Volo.Abp.Testing;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingAbstractionsTestBase : AbpIntegratedTest<AbpImagingAbstractionsTestModule>
+{
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    {
+        options.UseAutofac();
+    }
+}

framework/test/Volo.Abp.Imaging.Abstractions.Tests/Volo/Abp/Imaging/IImageCompressor_Tests.cs

@@ -0,0 +1,51 @@
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class IImageCompressor_Tests : AbpImagingAbstractionsTestBase
+{
+    protected IImageCompressor ImageCompressor { get; }
+
+    public IImageCompressor_Tests()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(jpegImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(pngImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(webpImage);
+    }
+}

framework/test/Volo.Abp.Imaging.Abstractions.Tests/Volo/Abp/Imaging/IImageResizer_Tests.cs

@@ -0,0 +1,50 @@
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class IImageResizer_Tests : AbpImagingAbstractionsTestBase
+{
+    protected IImageResizer ImageResizer { get; }
+
+    public IImageResizer_Tests()
+    {
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(jpegImage);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(pngImage);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(webpImage);
+    }
+}

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo.Abp.Imaging.AspNetCore.Tests.abppkg.json

@@ -0,0 +1,3 @@
+{
+  "role": "lib.test"
+}

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo.Abp.Imaging.AspNetCore.Tests.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <Import Project="..\..\..\common.test.props" />
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace />
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
+        <ProjectReference Include="..\Volo.Abp.Imaging.Abstractions.Tests\Volo.Abp.Imaging.Abstractions.Tests.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.AspNetCore\Volo.Abp.Imaging.AspNetCore.csproj" />
+    </ItemGroup>
+</Project>

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo/Abp/Imaging/AbpImagingAspNetCoreTestBase.cs

@@ -0,0 +1,11 @@
+using Volo.Abp.Testing;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingAspNetCoreTestBase : AbpIntegratedTest<AbpImagingAspNetCoreTestModule>
+{
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    {
+        options.UseAutofac();
+    }
+}

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo/Abp/Imaging/AbpImagingAspNetCoreTestModule.cs

@@ -0,0 +1,14 @@
+using Volo.Abp.Autofac;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Imaging;
+
+[DependsOn(
+    typeof(AbpAutofacModule),
+    typeof(AbpImagingAspNetCoreModule),
+    typeof(AbpTestBaseModule)
+)]
+public class AbpImagingAspNetCoreTestModule : AbpModule
+{
+
+}

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo/Abp/Imaging/CompressImageAttribute_Tests.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class CompressImageAttribute_Tests : AbpImagingAspNetCoreTestBase
+{
+    [Fact]
+    public async Task Should_Compressed_IFormFile()
+    {
+        var attribute = new CompressImageAttribute();
+        
+        var serviceScopeFactory = GetRequiredService<IServiceScopeFactory>();
+
+        await using var stream = ImageFileHelper.GetJpgTestFileStream();
+        
+        var actionExecutingContext = new ActionExecutingContext(
+            new ActionContext() {
+                HttpContext = new DefaultHttpContext() {
+                    ServiceScopeFactory = serviceScopeFactory
+                },
+                RouteData = new Microsoft.AspNetCore.Routing.RouteData(),
+                ActionDescriptor = new ControllerActionDescriptor(),
+            },
+            new List<IFilterMetadata>(),
+            new Dictionary<string, object>
+            {
+                {"file", new FormFile(stream, 0, stream.Length, "file", "test.jpg") {
+                    Headers = new HeaderDictionary(),
+                    ContentType = "image/jpeg"
+                }}
+            },
+            new object()
+        );
+        
+        await attribute.OnActionExecutionAsync(actionExecutingContext, async () => await Task.FromResult(new ActionExecutedContext(
+            actionExecutingContext,
+            new List<IFilterMetadata>(),
+            new object()
+        )));
+        
+        actionExecutingContext.ActionArguments["file"].ShouldNotBeNull();
+        actionExecutingContext.ActionArguments["file"].ShouldBeAssignableTo<IFormFile>();
+    }
+}

framework/test/Volo.Abp.Imaging.AspNetCore.Tests/Volo/Abp/Imaging/ResizeImageAttribute_Tests.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class ResizeImageAttribute_Tests : AbpImagingAspNetCoreTestBase
+{
+    [Fact]
+    public void Should_Init()
+    {
+        var attribute = new ResizeImageAttribute(100, 100);
+        
+        attribute.Width.ShouldBe(100);
+        attribute.Height.ShouldBe(100);
+    }
+    
+    [Fact]
+    public async Task Should_Resized_IFormFile()
+    {
+        var attribute = new ResizeImageAttribute(100, 100);
+        
+        var serviceScopeFactory = GetRequiredService<IServiceScopeFactory>();
+        await using var stream = ImageFileHelper.GetJpgTestFileStream();
+        
+        var actionExecutingContext = new ActionExecutingContext(
+            new ActionContext() {
+                HttpContext = new DefaultHttpContext() {
+                    ServiceScopeFactory = serviceScopeFactory
+                },
+                RouteData = new Microsoft.AspNetCore.Routing.RouteData(),
+                ActionDescriptor = new ControllerActionDescriptor(),
+            },
+            new List<IFilterMetadata>(),
+            new Dictionary<string, object>
+            {
+                {"file", new FormFile(stream, 0, stream.Length, "file", "test.jpg") {
+                    Headers = new HeaderDictionary(),
+                    ContentType = "image/jpeg"
+                }}
+            },
+            new object()
+        );
+        
+        await attribute.OnActionExecutionAsync(actionExecutingContext, async () => await Task.FromResult(new ActionExecutedContext(
+            actionExecutingContext,
+            new List<IFilterMetadata>(),
+            new object()
+        )));
+        
+        actionExecutingContext.ActionArguments["file"].ShouldNotBeNull();
+        actionExecutingContext.ActionArguments["file"].ShouldBeAssignableTo<IFormFile>();
+    }
+}

framework/test/Volo.Abp.Imaging.ImageSharp.Tests/Volo.Abp.Imaging.ImageSharp.Tests.abppkg.json

@@ -0,0 +1,3 @@
+{
+  "role": "lib.test"
+}

framework/test/Volo.Abp.Imaging.ImageSharp.Tests/Volo.Abp.Imaging.ImageSharp.Tests.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <Import Project="..\..\..\common.test.props" />
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace />
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
+        <ProjectReference Include="..\Volo.Abp.Imaging.Abstractions.Tests\Volo.Abp.Imaging.Abstractions.Tests.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.ImageSharp\Volo.Abp.Imaging.ImageSharp.csproj" />
+    </ItemGroup>
+</Project>
+

framework/test/Volo.Abp.Imaging.ImageSharp.Tests/Volo/Abp/Imaging/ImageSharpImageCompressor_Tests.cs

@@ -0,0 +1,79 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class ImageSharpImageCompressor_Tests : AbpImagingImageSharpTestBase
+{
+    public IImageCompressor ImageCompressor { get; }
+    public ImageSharpImageCompressor_Tests()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+    }
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+
+        compressedImage.ShouldNotBeNull();
+
+        if (compressedImage.State == ProcessState.Done)
+        {
+            compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        }else
+        {
+            compressedImage.Result.Length.ShouldBe(pngImage.Length);
+        }
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var byteArr = await jpegImage.GetAllBytesAsync();
+        
+        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
+        var compressedImage2 = await ImageCompressor.CompressAsync(byteArr);
+        
+        compressedImage1.ShouldNotBeNull();
+        compressedImage1.State.ShouldBe(ProcessState.Done);
+        
+        compressedImage2.ShouldNotBeNull();
+        compressedImage2.State.ShouldBe(ProcessState.Done);
+        
+        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
+        
+        compressedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.ImageSharp.Tests/Volo/Abp/Imaging/ImageSharpImageResizer_Tests.cs

@@ -0,0 +1,72 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class ImageSharpImageResizer_Tests : AbpImagingImageSharpTestBase
+{
+    public IImageResizer ImageResizer { get; }
+    
+    public ImageSharpImageResizer_Tests()
+    {
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+    }
+
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+    }
+
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var byteArr = await jpegImage.GetAllBytesAsync();
+        
+        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        var resizedImage2 = await ImageResizer.ResizeAsync(byteArr, new ImageResizeArgs(100, 100));
+        
+        resizedImage1.ShouldNotBeNull();
+        resizedImage1.State.ShouldBe(ProcessState.Done);
+        
+        resizedImage2.ShouldNotBeNull();
+        resizedImage2.State.ShouldBe(ProcessState.Done);
+        
+        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
+        
+        resizedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.MagickNet.Tests/Volo.Abp.Imaging.MagickNet.Tests.abppkg.json

@@ -0,0 +1,3 @@
+{
+  "role": "lib.test"
+}

framework/test/Volo.Abp.Imaging.MagickNet.Tests/Volo.Abp.Imaging.MagickNet.Tests.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <Import Project="..\..\..\common.test.props" />
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace />
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
+        <ProjectReference Include="..\Volo.Abp.Imaging.Abstractions.Tests\Volo.Abp.Imaging.Abstractions.Tests.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.MagickNet\Volo.Abp.Imaging.MagickNet.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <EmbeddedResource Include="Volo\Abp\Imaging\Files\**" />
+    </ItemGroup>
+</Project>

framework/test/Volo.Abp.Imaging.MagickNet.Tests/Volo/Abp/Imaging/MagickNetImageCompressor_Tests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class MagickNetImageCompressor_Tests : AbpImagingMagickNetTestBase
+{
+    public IImageCompressor ImageCompressor { get; }
+    
+    public MagickNetImageCompressor_Tests()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        compressedImage.Result.ShouldBe(webpImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
+        var compressedImage2 = await ImageCompressor.CompressAsync(await jpegImage.GetAllBytesAsync());
+
+        compressedImage1.ShouldNotBeNull();
+        compressedImage1.State.ShouldBe(ProcessState.Done);
+        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage2.ShouldNotBeNull();
+        compressedImage2.State.ShouldBe(ProcessState.Done);
+        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
+        
+        compressedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.MagickNet.Tests/Volo/Abp/Imaging/MagickNetImageResizer_Tests.cs

@@ -0,0 +1,75 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public class MagickNetImageResizer_Tests : AbpImagingMagickNetTestBase
+{
+    public IImageResizer ImageResizer { get; }
+    
+    public MagickNetImageResizer_Tests()
+    {
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        var resizedImage2 = await ImageResizer.ResizeAsync(await jpegImage.GetAllBytesAsync(), new ImageResizeArgs(100, 100));
+
+        resizedImage1.ShouldNotBeNull();
+        resizedImage1.State.ShouldBe(ProcessState.Done);
+        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage2.ShouldNotBeNull();
+        resizedImage2.State.ShouldBe(ProcessState.Done);
+        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
+        
+        resizedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingAbstractionsTestBase.cs

@@ -1,105 +0,0 @@
-using System.Threading.Tasks;
-using Shouldly;
-using Volo.Abp.Testing;
-using Xunit;
-
-namespace Volo.Abp.Imaging;
-
-public abstract class AbpImagingAbstractionsTestBase : AbpIntegratedTest<AbpImagingAbstractionsTestModule>
-{
-    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
-    {
-        options.UseAutofac();
-    }
-}
-
-public class IIImageResizer_Tests : AbpImagingAbstractionsTestBase
-{
-    protected IImageResizer ImageResizer { get; }
-
-    public IIImageResizer_Tests()
-    {
-        ImageResizer = GetRequiredService<IImageResizer>();
-    }
-    [Fact]
-    public async Task Should_Resize_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
-        
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        resizedImage.Result.ShouldBe(jpegImage);
-    }
-    
-    [Fact]
-    public async Task Should_Resize_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
-        
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        resizedImage.Result.ShouldBe(pngImage);
-    }
-    
-    [Fact]
-    public async Task Should_Resize_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
-        
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        resizedImage.Result.ShouldBe(webpImage);
-    }
-}
-
-public class IIImageCompressor_Tests : AbpImagingAbstractionsTestBase
-{
-    protected IImageCompressor ImageCompressor { get; }
-
-    public IIImageCompressor_Tests()
-    {
-        ImageCompressor = GetRequiredService<IImageCompressor>();
-    }
-    
-    [Fact]
-    public async Task Should_Compress_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
-        
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        compressedImage.Result.ShouldBe(jpegImage);
-    }
-    
-    [Fact]
-    public async Task Should_Compress_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
-        
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        compressedImage.Result.ShouldBe(pngImage);
-    }
-    
-    [Fact]
-    public async Task Should_Compress_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
-        
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Unsupported);
-        
-        compressedImage.Result.ShouldBe(webpImage);
-    }
-}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingImageSharpProviderTestBase.cs

@@ -1,139 +0,0 @@
-using System.IO;
-using System.Threading.Tasks;
-using Shouldly;
-using Xunit;
-
-namespace Volo.Abp.Imaging;
-
-public abstract class AbpImagingImageSharpProviderTestBase : AbpImagingImageSharpTestBase
-{
-    protected IImageCompressor ImageCompressor { get; }
-    protected IImageResizer ImageResizer { get; }
-
-    public AbpImagingImageSharpProviderTestBase()
-    {
-        ImageCompressor = GetRequiredService<IImageCompressor>();
-        ImageResizer = GetRequiredService<IImageResizer>();
-    }
-}
-
-public class ImageSharpImageCompressor_Tests : AbpImagingImageSharpProviderTestBase
-{
-    [Fact]
-    public async Task Should_Compress_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Done);
-        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        compressedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Compress_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Done);
-        compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
-        compressedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Compress_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Done);
-        compressedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
-        compressedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var byteArr = await jpegImage.GetAllBytesAsync();
-        
-        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
-        var compressedImage2 = await ImageCompressor.CompressAsync(byteArr);
-        
-        compressedImage1.ShouldNotBeNull();
-        compressedImage1.State.ShouldBe(ProcessState.Done);
-        
-        compressedImage2.ShouldNotBeNull();
-        compressedImage2.State.ShouldBe(ProcessState.Done);
-        
-        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
-        
-        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
-        
-        compressedImage1.Result.Dispose();
-    }
-}
-
-public class ImageSharpImageResizer_Tests : AbpImagingImageSharpProviderTestBase
-{
-    [Fact]
-    public async Task Should_Resize_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
-    }
-
-    [Fact]
-    public async Task Should_Resize_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
-    }
-
-    [Fact]
-    public async Task Should_Resize_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
-    }
-    
-    [Fact]
-    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var byteArr = await jpegImage.GetAllBytesAsync();
-        
-        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
-        var resizedImage2 = await ImageResizer.ResizeAsync(byteArr, new ImageResizeArgs(100, 100));
-        
-        resizedImage1.ShouldNotBeNull();
-        resizedImage1.State.ShouldBe(ProcessState.Done);
-        
-        resizedImage2.ShouldNotBeNull();
-        resizedImage2.State.ShouldBe(ProcessState.Done);
-        
-        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
-        
-        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
-        
-        resizedImage1.Result.Dispose();
-    }
-}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingMagickNetProviderTestBase.cs

@@ -1,141 +0,0 @@
-using System.IO;
-using System.Threading.Tasks;
-using Shouldly;
-using Xunit;
-
-namespace Volo.Abp.Imaging;
-
-public abstract class AbpImagingMagickNetProviderTestBase : AbpImagingMagickNetTestBase
-{
-    protected IImageCompressor ImageCompressor { get; }
-    protected IImageResizer ImageResizer { get; }
-
-    public AbpImagingMagickNetProviderTestBase()
-    {
-        ImageCompressor = GetRequiredService<IImageCompressor>();
-        ImageResizer = GetRequiredService<IImageResizer>();
-    }
-}
-
-
-public class MagickNetImageCompressor_Tests : AbpImagingMagickNetProviderTestBase
-{
-    [Fact]
-    public async Task Should_Compress_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Done);
-        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        
-        compressedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Compress_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Done);
-        compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
-        
-        compressedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Compress_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
-
-        compressedImage.ShouldNotBeNull();
-        compressedImage.State.ShouldBe(ProcessState.Unsupported);
-        compressedImage.Result.ShouldBe(webpImage);
-    }
-    
-    [Fact]
-    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
-        var compressedImage2 = await ImageCompressor.CompressAsync(await jpegImage.GetAllBytesAsync());
-
-        compressedImage1.ShouldNotBeNull();
-        compressedImage1.State.ShouldBe(ProcessState.Done);
-        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        
-        compressedImage2.ShouldNotBeNull();
-        compressedImage2.State.ShouldBe(ProcessState.Done);
-        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
-        
-        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
-        
-        compressedImage1.Result.Dispose();
-    }
-}
-
-public class MagickNetImageResizer_Tests : AbpImagingMagickNetProviderTestBase
-{
-    [Fact]
-    public async Task Should_Resize_Jpg()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        
-        resizedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Resize_Png()
-    {
-        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
-        
-        resizedImage.Result.Dispose();
-    }
-
-    [Fact]
-    public async Task Should_Resize_Webp()
-    {
-        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
-        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
-
-        resizedImage.ShouldNotBeNull();
-        resizedImage.State.ShouldBe(ProcessState.Done);
-        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
-        
-        resizedImage.Result.Dispose();
-    }
-    
-    [Fact]
-    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
-    {
-        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
-        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
-        var resizedImage2 = await ImageResizer.ResizeAsync(await jpegImage.GetAllBytesAsync(), new ImageResizeArgs(100, 100));
-
-        resizedImage1.ShouldNotBeNull();
-        resizedImage1.State.ShouldBe(ProcessState.Done);
-        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
-        
-        resizedImage2.ShouldNotBeNull();
-        resizedImage2.State.ShouldBe(ProcessState.Done);
-        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
-        
-        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
-        
-        resizedImage1.Result.Dispose();
-    }
-}