public void Test_IsSupported()
        {
            ImageOptimizer optimizer = new ImageOptimizer();

            ExceptionAssert.Throws <ArgumentNullException>(delegate()
            {
                optimizer.IsSupported((FileInfo)null);
            });

            ExceptionAssert.Throws <ArgumentNullException>(delegate()
            {
                optimizer.IsSupported((string)null);
            });

            ExceptionAssert.Throws <ArgumentException>(delegate()
            {
                optimizer.IsSupported("");
            });

            Assert.IsTrue(optimizer.IsSupported(Files.FujiFilmFinePixS1ProGIF));
            Assert.IsTrue(optimizer.IsSupported(Files.ImageMagickJPG));
            Assert.IsTrue(optimizer.IsSupported(Files.SnakewarePNG));
            Assert.IsTrue(optimizer.IsSupported(Files.Missing));
            Assert.IsFalse(optimizer.IsSupported(Files.InvitationTif));
        }
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            await Task.Delay(5000);

            logger.LogInformation("Start ExistingImageOptimizer");
            string[] files   = Directory.GetFiles(environment.WebRootPath, "*", SearchOption.AllDirectories);
            string[] filters = new string[]
            {
                ".ico", ".jpeg", ".jpg", ".png", ".gif", ".tiff", ".bmp",
                ".ICO", ".JPEG", ".JPG", ".PNG", ".GIF", ".TIFF", ".BMP"
            };
            files = files.Where(file => filters.Contains(Path.GetExtension(file))).ToArray();
            int index      = 0;
            int errorCount = 0;

            while (!stoppingToken.IsCancellationRequested && index < files.Length)
            {
                string file = files[index++];
                if (imageOptimizer.IsSupported(file))
                {
                    try
                    {
                        imageOptimizer.Compress(file);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message, "ExistingImageOptimizer");
                        errorCount++;
                    }
                }
            }

            logger.LogInformation($"ExistingImageOptimizer Work done Error Count : {errorCount}");
        }
                public void ShouldThrowExceptionWhenFileIsNull()
                {
                    var optimizer = new ImageOptimizer();

                    ExceptionAssert.ThrowsArgumentNullException("file", () =>
                    {
                        optimizer.IsSupported((FileInfo)null);
                    });
                }
                public void ShouldReturnFalseWhenStreamCannotSeek()
                {
                    var optimizer = new ImageOptimizer();

                    using (TestStream stream = new TestStream(true, true, false))
                    {
                        Assert.IsFalse(optimizer.IsSupported(stream));
                    }
                }
                public void ShouldThrowExceptionWhenStreamIsNull()
                {
                    var optimizer = new ImageOptimizer();

                    ExceptionAssert.Throws <ArgumentNullException>("stream", () =>
                    {
                        optimizer.IsSupported((Stream)null);
                    });
                }
                public void ShouldThrowExceptionWhenFileNameIsEmpty()
                {
                    var optimizer = new ImageOptimizer();

                    ExceptionAssert.Throws <ArgumentException>("fileName", () =>
                    {
                        optimizer.IsSupported(string.Empty);
                    });
                }
                public void ShouldReturnFalseWhenStreamCannotRead()
                {
                    var optimizer = new ImageOptimizer();

                    using (var stream = new TestStream(false, true, true))
                    {
                        Assert.False(optimizer.IsSupported(stream));
                    }
                }
        internal static bool CanOptimize(MagickFormatInfo formatInfo)
        {
            if (!MagickWebSettings.OptimizeImages)
            {
                return(false);
            }

            return(_ImageOptimizer.IsSupported(formatInfo));
        }
                public void ShouldThrowExceptionWhenFileNameIsNull()
                {
                    var optimizer = new ImageOptimizer();

                    ExceptionAssert.Throws <ArgumentNullException>("fileName", () =>
                    {
                        optimizer.IsSupported((string)null);
                    });
                }
Beispiel #10
0
        public static bool CanOptimize(MagickWebSettings settings, MagickFormatInfo formatInfo)
        {
            if (!settings.Optimization.IsEnabled)
            {
                return(false);
            }

            return(_ImageOptimizer.IsSupported(formatInfo));
        }
                public void ShouldReturnTrueWhenStreamIsGifFile()
                {
                    var optimizer = new ImageOptimizer();

                    using (FileStream fileStream = OpenStream(Files.FujiFilmFinePixS1ProGIF))
                    {
                        Assert.IsTrue(optimizer.IsSupported(fileStream));
                        Assert.AreEqual(0, fileStream.Position);
                    }
                }
                public void ShouldReturnTrueWhenStreamIsIcoFile()
                {
                    var optimizer = new ImageOptimizer();

                    using (FileStream fileStream = OpenStream(Files.WandICO))
                    {
                        Assert.IsTrue(optimizer.IsSupported(fileStream));
                        Assert.AreEqual(0, fileStream.Position);
                    }
                }
                public void ShouldReturnTrueWhenStreamIsPngFile()
                {
                    var optimizer = new ImageOptimizer();

                    using (var fileStream = OpenStream(Files.SnakewarePNG))
                    {
                        Assert.True(optimizer.IsSupported(fileStream));
                        Assert.Equal(0, fileStream.Position);
                    }
                }
                public void ShouldReturnFalseWhenStreamIsTifFile()
                {
                    var optimizer = new ImageOptimizer();

                    using (FileStream fileStream = OpenStream(Files.InvitationTIF))
                    {
                        Assert.IsFalse(optimizer.IsSupported(fileStream));
                        Assert.AreEqual(0, fileStream.Position);
                    }
                }
Beispiel #15
0
 public static void Optimize(this ImageOptimizer imageOptimizer, string file, [FromServices] ILogger <ImageOptimizer> logger)
 {
     if (imageOptimizer.IsSupported(file))
     {
         try
         {
             imageOptimizer.Compress(file);
         }
         catch (Exception ex)
         {
             logger.LogWarning(ex.Message);
         }
     }
 }
                public void ShouldReturnTrueWhenFileIsMissingPngFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsTrue(optimizer.IsSupported(new FileInfo(Files.Missing)));
                }
                public void ShouldReturnFalseWhenFileNameIsInvalid()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsFalse(optimizer.IsSupported("invalid"));
                }
                public void ShouldReturnTrueWhenFileIsFileIsJpgFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsTrue(optimizer.IsSupported(new FileInfo(Files.ImageMagickJPG)));
                }
                public void ShouldReturnFalseWhenFileIsFileIsTifFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsFalse(optimizer.IsSupported(new FileInfo(Files.InvitationTIF)));
                }
                public void ShouldReturnTrueWhenFileIsFileIsGifFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsTrue(optimizer.IsSupported(new FileInfo(Files.FujiFilmFinePixS1ProGIF)));
                }
                public void ShouldReturnTrueWhenFileIsFileIsIcoFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsTrue(optimizer.IsSupported(new FileInfo(Files.WandICO)));
                }
                public void ShouldReturnTrueWhenFileIsFileIsPngFile()
                {
                    var optimizer = new ImageOptimizer();

                    Assert.IsTrue(optimizer.IsSupported(new FileInfo(Files.SnakewarePNG)));
                }