Implement Tests

Author: karami-mehdi

core/model_generator.py

@@ -30,7 +30,7 @@ def get_voice_classification_model(self):
     @classmethod
     def _build_cnn(self, input_shape, num_classes):
         model = models.Sequential()
-        model.add(layers.InputLayer(input_shape=input_shape))
+        model.add(layers.InputLayer(shape=input_shape))
         model.add(layers.Conv2D(32, (3, 3), activation='relu'))
         model.add(layers.MaxPooling2D((2, 2)))
         model.add(layers.Conv2D(64, (3, 3), activation='relu'))

test/test_model_generator.py

@@ -0,0 +1,52 @@
+import pytest
+from tensorflow.keras.models import Model
+from sklearn.svm import SVC
+from core.model_generator import ModelGenerator
+
+def test_get_image_classification_model_cnn():
+    input_shape = (64, 64, 3)
+    model = ModelGenerator.get_image_classification_model("CNN (Recommended)", input_shape, num_classes=1)
+    assert isinstance(model, Model)
+    assert model.input_shape[1:] == input_shape
+    assert model.output_shape[-1] == 1
+    assert model.loss == 'sparse_categorical_crossentropy'
+
+def test_get_image_classification_model_svm():
+    model = ModelGenerator.get_image_classification_model("SVM", input_shape=(64,64,3))
+    assert isinstance(model, SVC)
+    assert model.kernel == "linear"
+    assert model.probability is True
+
+def test_get_image_classification_model_invalid_algorithm():
+    with pytest.raises(ValueError):
+        ModelGenerator.get_image_classification_model("InvalidAlgo", input_shape=(64,64,3))
+
+def test_get_image_segmentation_model_unet():
+    input_shape = (128, 128, 3)
+    num_classes = 1
+    model = ModelGenerator.get_image_segmentation_model("U-Net (Recommended)", input_shape, num_classes)
+    assert isinstance(model, Model)
+    assert model.input_shape[1:] == input_shape
+    assert model.output_shape[-1] == num_classes
+    # Check loss for binary classification
+    assert model.loss == 'binary_crossentropy'
+
+def test_get_image_segmentation_model_cnn():
+    input_shape = (128, 128, 3)
+    num_classes = 2
+    model = ModelGenerator.get_image_segmentation_model("CNN", input_shape, num_classes)
+    assert isinstance(model, Model)
+    assert model.output_shape[-1] == num_classes
+    # Multi-class last layer activation softmax
+    last_layer_activation = model.layers[-1].activation.__name__
+    assert last_layer_activation == "softmax"
+
+def test_get_image_segmentation_model_invalid_algorithm():
+    with pytest.raises(ValueError):
+        ModelGenerator.get_image_segmentation_model("InvalidAlgo", input_shape=(64,64,3))
+
+def test_get_voice_classification_model_returns_svc():
+    model = ModelGenerator.get_voice_classification_model()
+    assert isinstance(model, SVC)
+    assert model.kernel == "linear"
+    assert model.probability is True

test/test_model_trainer.py

@@ -0,0 +1,123 @@
+import numpy as np
+import pandas as pd
+import pytest
+import torch
+from torchvision.datasets import ImageFolder
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from core.model_trainer import ModelTrainer
+from core.model_generator import ModelGenerator
+from unittest.mock import MagicMock
+
+# ----------- UTILITIES -----------
+
+class DummyImageFolder(ImageFolder):
+    def __init__(self, transform=None):
+        self.samples = [(None, 0)] * 10
+        self.targets = [0] * 10
+        self.classes = ['class0']
+        self.imgs = self.samples
+        self.transform = transform
+
+    def __len__(self):
+        return 10
+
+    def __getitem__(self, index):
+        image = torch.randn(1, 128, 128)  # 1-channel image
+        mask = torch.randint(0, 2, (128, 128))  # segmentation mask (binary)
+        return image, mask
+
+# ----------- TEST CASES -----------
+
+def test_train_image_classification_cnn(monkeypatch):
+    # Create a dummy tabular dataset
+    data = pd.DataFrame(np.random.rand(100, 5))
+    data.iloc[:, -1] = np.random.randint(0, 3, size=100)
+    trainer = ModelTrainer(data)
+
+    # Patch model.fit to avoid actual training
+    dummy_model = ModelGenerator.get_image_classification_model("CNN (Recommended)", input_shape=(128, 128, 1), num_classes=3)
+    dummy_model.fit = MagicMock(return_value=None)
+
+    monkeypatch.setattr(ModelGenerator, "get_image_classification_model", lambda *args, **kwargs: dummy_model)
+
+    model = trainer.train("Image Classification", "CNN (Recommended)")
+    assert model is not None
+    dummy_model.fit.assert_called_once()
+
+
+def test_train_image_classification_svm():
+    # Create dummy tabular dataset
+    data = pd.DataFrame(np.random.rand(50, 4))
+    data.iloc[:, -1] = np.random.randint(0, 2, size=50)
+    trainer = ModelTrainer(data)
+
+    model = trainer.train("Image Classification", "SVM")
+    assert hasattr(model, "fit")
+    assert hasattr(model, "predict")
+
+
+def test_train_image_segmentation_unet(monkeypatch):
+    # Fake image dataset for segmentation
+    dataset = DummyImageFolder()
+    trainer = ModelTrainer(dataset)
+
+    # Patch model.fit to skip training
+    dummy_model = ModelGenerator.get_image_segmentation_model("U-Net (Recommended)", input_shape=(128, 128, 1), num_classes=1)
+    dummy_model.fit = MagicMock(return_value=None)
+
+    monkeypatch.setattr(ModelGenerator, "get_image_segmentation_model", lambda *args, **kwargs: dummy_model)
+
+    model = trainer.train("Image Segmentation", "U-Net (Recommended)")
+    assert model is not None
+    dummy_model.fit.assert_called_once()
+
+
+def test_train_image_segmentation_cnn(monkeypatch):
+    dataset = DummyImageFolder()
+    trainer = ModelTrainer(dataset)
+
+    dummy_model = ModelGenerator.get_image_segmentation_model("CNN", input_shape=(128, 128, 1), num_classes=1)
+    dummy_model.fit = MagicMock(return_value=None)
+
+    monkeypatch.setattr(ModelGenerator, "get_image_segmentation_model", lambda *args, **kwargs: dummy_model)
+
+    model = trainer.train("Image Segmentation", "CNN")
+    assert model is not None
+    dummy_model.fit.assert_called_once()
+
+
+def test_train_voice_classification(monkeypatch):
+    # Create dummy voice features as tabular data
+    data = pd.DataFrame(np.random.rand(60, 20))
+    data.iloc[:, -1] = np.random.randint(0, 2, size=60)
+    trainer = ModelTrainer(data)
+
+    dummy_model = ModelGenerator.get_voice_classification_model()
+    dummy_model.fit = MagicMock(return_value=None)
+
+    monkeypatch.setattr(ModelGenerator, "get_voice_classification_model", lambda: dummy_model)
+
+    model = trainer.train("Voice Classification", "")
+    assert model is not None
+    dummy_model.fit.assert_called_once()
+
+
+def test_invalid_model_type_raises():
+    data = pd.DataFrame(np.random.rand(10, 4))
+    trainer = ModelTrainer(data)
+
+    with pytest.raises(ValueError):
+        trainer.train("Unknown Task", "")
+
+def test_invalid_task_type_raises():
+    data = pd.DataFrame(np.random.rand(10, 4))
+    trainer = ModelTrainer(data)
+
+    with pytest.raises(ValueError):
+        trainer.train("Image Classification", "UnknownModel")
+
+def test_invalid_dataset_type_raises():
+    invalid_data = "I am not a dataset"
+    with pytest.raises(TypeError):
+        ModelTrainer(invalid_data)

test/uitest_trainer_widget.py

@@ -0,0 +1,53 @@
+import pytest
+import pandas as pd
+from torchvision.datasets import ImageFolder
+from unittest.mock import MagicMock, patch
+from PyQt6.QtWidgets import QApplication, QFileDialog
+from presentation.widgets.trainer_widget import TrainerWidget
+
+@pytest.fixture
+def trainer_widget(qtbot):
+    """Create and return a TrainerWidget instance."""
+    widget = TrainerWidget()
+    qtbot.addWidget(widget)
+    widget.show()  # optional, can be useful for some tests
+    return widget
+
+@pytest.fixture
+def valid_dataframe_dataset():
+    return pd.DataFrame({'feature1': [1, 2], 'feature2': [3, 4], 'label': [0, 1]})
+
+@pytest.fixture
+def valid_imagefolder_dataset(tmp_path):
+    class_to_dir = tmp_path / "class_a"
+    class_to_dir.mkdir()
+    dummy_file = class_to_dir / "dummy.jpg"
+    dummy_file.write_text("dummy content")
+    return ImageFolder(str(tmp_path))
+
+def test_model_selection_shows_algorithms(trainer_widget, qtbot, valid_dataframe_dataset):
+    trainer_widget.dataset = valid_dataframe_dataset
+    trainer_widget.model_combobox.setCurrentIndex(1)
+    qtbot.wait(100)
+    assert trainer_widget.algorithm_label.isVisible()
+
+def test_train_model_button_behavior(trainer_widget, qtbot, valid_dataframe_dataset):
+    trainer_widget.dataset = valid_dataframe_dataset
+    with patch("presentation.widgets.trainer_widget.ModelTrainer.train", return_value=MagicMock()) as mock_train:
+        trainer_widget.train_model()
+        qtbot.wait(100)
+        mock_train.assert_called_once()
+
+def test_save_model_button_behavior(trainer_widget, qtbot, valid_dataframe_dataset, tmp_path, monkeypatch):
+    trainer_widget.dataset = valid_dataframe_dataset
+    trainer_widget.model = MagicMock()
+
+    fake_path = str(tmp_path / "model.pth")
+
+    # Patch QFileDialog.getSaveFileName globally
+    monkeypatch.setattr(QFileDialog, "getSaveFileName", lambda *args, **kwargs: (fake_path, 'All Files (*)'))
+
+    # Patch the actual saving logic to prevent real file I/O and serialization
+    with patch("presentation.widgets.trainer_widget.save_model_to_file") as mock_save:
+        trainer_widget.save_model()
+        mock_save.assert_called_once_with(trainer_widget.model, fake_path)