feat(tests): test coverage is 69.2

test/core/image_compressing/image_compress_utility_test.dart

@@ -208,5 +208,223 @@ void main() {
         }
       }
     });
+
+    test('compressFilesList - обрабатывает список с изображениями разных форматов', () async {
+      final jpegFile = File('test_file.jpg');
+      final pngFile = File('test_file.png');
+      final gifFile = File('test_file.gif');
+      final nonImageFile = File('test_file.txt');
+
+      try {
+        // Создаем минимальные файлы
+        await jpegFile.writeAsBytes([0xFF, 0xD8, 0xFF, 0xE0]);
+        await pngFile.writeAsBytes([0x89, 0x50, 0x4E, 0x47]);
+        await gifFile.writeAsBytes([0x47, 0x49, 0x46, 0x38]);
+        await nonImageFile.writeAsBytes([0x54, 0x45, 0x58, 0x54]);
+
+        final testFiles = [jpegFile, pngFile, gifFile, nonImageFile];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 4);
+        // В тестовом окружении все файлы возвращаются как есть
+        expect(result[0].path, jpegFile.path);
+        expect(result[1].path, pngFile.path);
+        expect(result[2].path, gifFile.path);
+        expect(result[3].path, nonImageFile.path);
+      } finally {
+        for (final file in [jpegFile, pngFile, gifFile, nonImageFile]) {
+          if (await file.exists()) {
+            await file.delete();
+          }
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает пустой список', () async {
+      final result = await ImageCompressUtility.compressFilesList([]);
+
+      expect(result, isA<List<File>>());
+      expect(result.length, 0);
+    });
+
+    test('compressFilesList - обрабатывает список только с не-изображениями', () async {
+      final txtFile = File('test_file.txt');
+      final pdfFile = File('test_file.pdf');
+
+      try {
+        await txtFile.writeAsBytes([0x54, 0x45, 0x58, 0x54]);
+        await pdfFile.writeAsBytes([0x25, 0x50, 0x44, 0x46]);
+
+        final testFiles = [txtFile, pdfFile];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 2);
+        expect(result[0].path, txtFile.path);
+        expect(result[1].path, pdfFile.path);
+      } finally {
+        for (final file in [txtFile, pdfFile]) {
+          if (await file.exists()) {
+            await file.delete();
+          }
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает файлы с разными расширениями изображений', () async {
+      final jpgFile = File('test_file.jpg');
+      final jpegFile = File('test_file.jpeg');
+      final pngFile = File('test_file.PNG'); // uppercase
+      final bmpFile = File('test_file.bmp');
+      final webpFile = File('test_file.webp');
+
+      try {
+        await jpgFile.writeAsBytes([0xFF, 0xD8]);
+        await jpegFile.writeAsBytes([0xFF, 0xD8]);
+        await pngFile.writeAsBytes([0x89, 0x50]);
+        await bmpFile.writeAsBytes([0x42, 0x4D]);
+        await webpFile.writeAsBytes([0x52, 0x49, 0x46, 0x46]);
+
+        final testFiles = [jpgFile, jpegFile, pngFile, bmpFile, webpFile];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 5);
+      } finally {
+        for (final file in [jpgFile, jpegFile, pngFile, bmpFile, webpFile]) {
+          if (await file.exists()) {
+            await file.delete();
+          }
+        }
+      }
+    });
+
+    test('compressFile - обрабатывает PNG файл', () async {
+      final pngFile = File('test_file.png');
+      try {
+        // Минимальный валидный PNG
+        final pngBytes = [
+          0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature
+          0x00, 0x00, 0x00, 0x0D, // IHDR chunk length
+          0x49, 0x48, 0x44, 0x52, // IHDR
+          0x00, 0x00, 0x00, 0x01, // width
+          0x00, 0x00, 0x00, 0x01, // height
+          0x08, 0x02, 0x00, 0x00, 0x00, // bit depth, color type, etc.
+          0x90, 0x77, 0x53, 0xDE, // CRC
+          0x00, 0x00, 0x00, 0x00, // IEND chunk length
+          0x49, 0x45, 0x4E, 0x44, // IEND
+          0xAE, 0x42, 0x60, 0x82, // CRC
+        ];
+        await pngFile.writeAsBytes(pngBytes);
+
+        final result = await ImageCompressUtility.compressFile(pngFile);
+
+        expect(result, isA<File>());
+        expect(result.path, pngFile.path);
+      } finally {
+        if (await pngFile.exists()) {
+          await pngFile.delete();
+        }
+      }
+    });
+
+    test('compressFile - обрабатывает файл с расширением в верхнем регистре', () async {
+      final jpgFile = File('test_file.JPG');
+      try {
+        final jpegBytes = [0xFF, 0xD8, 0xFF, 0xE0];
+        await jpgFile.writeAsBytes(jpegBytes);
+
+        final result = await ImageCompressUtility.compressFile(jpgFile);
+
+        expect(result, isA<File>());
+        expect(result.path, jpgFile.path);
+      } finally {
+        if (await jpgFile.exists()) {
+          await jpgFile.delete();
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает смешанный список изображений и не-изображений', () async {
+      final jpgFile = File('test_file.jpg');
+      final txtFile = File('test_file.txt');
+      final pngFile = File('test_file.png');
+
+      try {
+        await jpgFile.writeAsBytes([0xFF, 0xD8]);
+        await txtFile.writeAsBytes([0x54, 0x45, 0x58, 0x54]);
+        await pngFile.writeAsBytes([0x89, 0x50]);
+
+        final testFiles = [jpgFile, txtFile, pngFile];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 3);
+        expect(result[0].path, jpgFile.path);
+        expect(result[1].path, txtFile.path);
+        expect(result[2].path, pngFile.path);
+      } finally {
+        for (final file in [jpgFile, txtFile, pngFile]) {
+          if (await file.exists()) {
+            await file.delete();
+          }
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает файлы с длинными путями', () async {
+      final longPathFile = File('very_long_path_name_for_testing_image_compression.jpg');
+      try {
+        await longPathFile.writeAsBytes([0xFF, 0xD8]);
+
+        final testFiles = [longPathFile];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 1);
+        expect(result[0].path, longPathFile.path);
+      } finally {
+        if (await longPathFile.exists()) {
+          await longPathFile.delete();
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает файлы с точками в имени', () async {
+      final fileWithDots = File('test.file.name.jpg');
+      try {
+        await fileWithDots.writeAsBytes([0xFF, 0xD8]);
+
+        final testFiles = [fileWithDots];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 1);
+        expect(result[0].path, fileWithDots.path);
+      } finally {
+        if (await fileWithDots.exists()) {
+          await fileWithDots.delete();
+        }
+      }
+    });
+
+    test('compressFilesList - обрабатывает файлы без расширения', () async {
+      final fileNoExt = File('test_file_no_extension');
+      try {
+        await fileNoExt.writeAsBytes([0xFF, 0xD8]);
+
+        final testFiles = [fileNoExt];
+        final result = await ImageCompressUtility.compressFilesList(testFiles);
+
+        expect(result, isA<List<File>>());
+        expect(result.length, 1);
+        expect(result[0].path, fileNoExt.path);
+      } finally {
+        if (await fileNoExt.exists()) {
+          await fileNoExt.delete();
+        }
+      }
+    });
   });
 }