feat: refactor image captioning tests and add ESLint configuration

Author: LightCyan01

.eslintrc.json

@@ -1,4 +1,4 @@
-name: Build
+name: Build & Release
 
 on:
   push:
@@ -7,57 +7,51 @@ on:
 
 jobs:
   build:
-    name: Build ${{ matrix.os }}
+    name: Build (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            artifact: linux
+          - os: windows-latest
+            artifact: windows
+          - os: macos-latest
+            artifact: macos
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v5
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v5
+      - uses: actions/setup-node@v5
         with:
           node-version: 20
           cache: "npm"
 
-      - name: Install dependencies
-        run: npm ci
+      - run: npm ci
+      - run: npm run make
 
-      - name: Build application
-        run: npm run make
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v4
         with:
-          name: TrainKit-${{ matrix.os }}
-          path: |
-            out/make/**/*
+          name: TrainKit-${{ matrix.artifact }}
+          path: out/make/**/*
           retention-days: 30
 
   release:
-    name: Create Release
+    name: Release
     needs: build
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/v')
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v5
 
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v4
         with:
           path: artifacts
 
-      - name: Create Release
-        uses: softprops/action-gh-release@v1
+      - uses: softprops/action-gh-release@v1
         with:
           files: artifacts/**/*
-          draft: false
-          prerelease: false
           generate_release_notes: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yml

@@ -2,64 +2,44 @@ name: CI
 
 on:
   push:
+    branches: [master, main]
   pull_request:
+    branches: [master, main]
 
 jobs:
   frontend:
-    name: Frontend Tests
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        node-version: [18, 20]
+    name: Frontend
+    runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v5
 
-      - name: Setup Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v5
+      - uses: actions/setup-node@v5
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: 20
           cache: "npm"
 
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run ESLint
-        run: npm run lint
-
-      - name: Build application
-        run: npm run package
+      - run: npm ci
+      - run: npm run lint
+      - run: npm run package
 
   backend:
-    name: Backend Tests
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.10", "3.11", "3.12"]
+    name: Backend
+    runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v5
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
+      - uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.19"
 
-      - name: Set up Python ${{ matrix.python-version }}
-        run: uv python install ${{ matrix.python-version }}
-
-      - name: Install dependencies
+      - run: uv python install 3.10
+      - run: uv sync --group dev
         working-directory: ./backend
-        run: uv sync --group dev
 
-      - name: Run Python linting
+      - run: uv run ruff check .
         working-directory: ./backend
-        run: uv run ruff check .
 
-      - name: Run Python tests
+      - run: uv run pytest
         working-directory: ./backend
-        run: uv run pytest

.github/workflows/ci.yml

@@ -0,0 +1 @@
+Subproject commit ebf414ea497a020da0f82df3913e5b6cb8e9663a

backend/llama-joycaption-beta-one-hf-llava

@@ -1,16 +1,28 @@
 import pytest
 from unittest.mock import MagicMock, patch
-from service.image_captioning import ImageCaptioning
+from pathlib import Path
+from service.image_captioning import ImageCaptioningService
 
 @pytest.fixture
-def dummy_captioner():
+def dummy_captioner(tmp_path):
     with patch('service.image_captioning.LlavaForConditionalGeneration.from_pretrained') as mock_model, \
          patch('service.image_captioning.AutoProcessor.from_pretrained') as mock_processor:
         mock_model.return_value = MagicMock()
         processor_instance = MagicMock()
-        # Set the processor mock to return our processor_instance
         mock_processor.return_value = processor_instance
-        captioner = ImageCaptioning("dummy-model")
+        
+        load_path = tmp_path / "load"
+        save_path = tmp_path / "save"
+        load_path.mkdir()
+        save_path.mkdir()
+        
+        captioner = ImageCaptioningService(
+            model=Path("dummy-model"),
+            load_path=load_path,
+            save_path=save_path,
+            prompt="Describe this image."
+        )
+        
         # Mock methods used in the pipeline
         captioner._model.generate = MagicMock(return_value=[[1, 2, 3, 4]])
         processor_instance.apply_chat_template = MagicMock(return_value="prompt")
@@ -19,7 +31,6 @@ def dummy_captioner():
             "pixel_values": MagicMock()
         }
         processor_instance.tokenizer.decode = MagicMock(return_value="A cat on a mat.")
-        # Make sure the processor mock is used for __call__
         captioner._processor = processor_instance
         return captioner
 
@@ -28,7 +39,7 @@ def test_image_inputs(dummy_captioner, tmp_path):
     img_path = tmp_path / "test.jpg"
     from PIL import Image
     Image.new("RGB", (10, 10)).save(img_path)
-    inputs = dummy_captioner._image_inputs(img_path, "Describe this image.")
+    inputs = dummy_captioner._image_inputs(img_path)
     assert "input_ids" in inputs
 
 def test_generate_caption(dummy_captioner):
@@ -44,7 +55,7 @@ def test_save_caption(dummy_captioner, tmp_path):
     img_path = tmp_path / "test.jpg"
     img_path.touch()
     caption = "A cat on a mat."
-    output_file = dummy_captioner.save_caption(caption, img_path)
+    output_file = dummy_captioner.save_caption(caption, img_path, tmp_path)
     assert output_file.exists()
     with open(output_file, "r", encoding="utf-8") as f:
         assert f.read() == caption

backend/tests/test_image_captioning.py

@@ -3,7 +3,7 @@
 import shutil
 from pathlib import Path
 from PIL import Image
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, patch, MagicMock
 from service.image_upscaling import ImageUpscaleService
 import torch
 
@@ -24,36 +24,75 @@ def temp_dirs():
 
 
 @pytest.fixture
-def image_service():
+def image_service(temp_dirs):
+    input_dir, output_dir = temp_dirs
+    
     with patch('service.image_upscaling.ModelLoader') as mock_loader:
-        # Create a mock model that returns the same tensor (no actual upscaling)
+        # Create a mock model descriptor
         mock_model = Mock()
         mock_model.to.return_value = mock_model
         mock_model.eval.return_value = mock_model
-        mock_model.device = "cpu"
-        mock_model.return_value = torch.rand(1, 3, 100, 100) 
+        mock_model.return_value = torch.rand(1, 3, 100, 100)
+        
+        mock_descriptor = Mock()
+        mock_descriptor.model = mock_model
+        mock_descriptor.scale = 2
+        mock_descriptor.tiling = True
 
-        mock_loader.return_value.load_from_file.return_value = mock_model
+        mock_loader.return_value.load_from_file.return_value = mock_descriptor
 
-        return ImageUpscaleService("dummy_model_path.pth", "cpu")
+        service = ImageUpscaleService(
+            device="cpu",
+            model_path=Path("dummy_model.pth"),
+            load_path=input_dir,
+            save_path=output_dir,
+            format="jpg"
+        )
+        return service
 
 
 def test_upscale_default_format(image_service, temp_dirs):
     """Test upscaling with default JPG format."""
     input_dir, output_dir = temp_dirs
 
-    image_service.upscale(str(input_dir), str(output_dir))
+    # Mock the upscale_with_tiler to avoid actual processing
+    with patch.object(image_service, 'upscale_with_tiler') as mock_upscale:
+        mock_upscale.return_value = Image.new('RGB', (200, 200), color='blue')
+        image_service.upscale()
 
     output_files = list(output_dir.glob("*.*"))
     assert len(output_files) == 1
     assert output_files[0].suffix == ".jpg"
 
 
-def test_upscale_format_conversion(image_service, temp_dirs):
+def test_upscale_format_conversion(temp_dirs):
     """Test upscaling with format conversion."""
     input_dir, output_dir = temp_dirs
 
-    image_service.upscale(str(input_dir), str(output_dir), "png")
+    with patch('service.image_upscaling.ModelLoader') as mock_loader:
+        mock_model = Mock()
+        mock_model.to.return_value = mock_model
+        mock_model.eval.return_value = mock_model
+        mock_model.return_value = torch.rand(1, 3, 100, 100)
+        
+        mock_descriptor = Mock()
+        mock_descriptor.model = mock_model
+        mock_descriptor.scale = 2
+        mock_descriptor.tiling = True
+        
+        mock_loader.return_value.load_from_file.return_value = mock_descriptor
+        
+        service = ImageUpscaleService(
+            device="cpu",
+            model_path=Path("dummy_model.pth"),
+            load_path=input_dir,
+            save_path=output_dir,
+            format="png"  # Convert to PNG
+        )
+        
+        with patch.object(service, 'upscale_with_tiler') as mock_upscale:
+            mock_upscale.return_value = Image.new('RGB', (200, 200), color='blue')
+            service.upscale()
 
     output_files = list(output_dir.glob("*.png"))
     assert len(output_files) == 1
@@ -62,10 +101,10 @@ def test_upscale_format_conversion(image_service, temp_dirs):
         assert img.format == "PNG"
 
 
-def test_get_supported_formats():
-    """Test getting supported output formats."""
-    formats = ImageUpscaleService.get_supported_output_formats()
+def test_supported_formats():
+    """Test that supported formats are defined."""
+    from config.image_formats import SUPPORTED_OUTPUT_FORMATS
 
-    assert isinstance(formats, list)
-    assert len(formats) > 0
-    assert all("value" in fmt and "label" in fmt for fmt in formats)
+    assert isinstance(SUPPORTED_OUTPUT_FORMATS, dict)
+    assert len(SUPPORTED_OUTPUT_FORMATS) > 0
+    assert "jpg" in SUPPORTED_OUTPUT_FORMATS or "jpeg" in SUPPORTED_OUTPUT_FORMATS