add unit tests

Author: vpchung

.github/workflows/test.yml

@@ -0,0 +1,40 @@
+name: Test
+
+on:
+  push:
+    branches: [ main, develop, fix-*, feat-* ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11', '3.12']
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .
+        pip install pytest pytest-cov pandas
+        
+    - name: Run unit tests
+      run: |
+        python -m pytest tests/ -v --tb=short --cov=cnb_tools --cov-report=term-missing
+    
+    - name: Test CLI basics
+      run: |
+        cnb-tools
+        cnb-tools --help
+        cnb-tools submission --help
+

docs/changelog/release-notes.md

@@ -15,6 +15,7 @@
 
 ### Internal
 - Drop support for Python 3.9 (reached [end of life](https://devguide.python.org/versions/))
+- Add unit tests
 
 ## 0.3.2
 

tests/__init__.py

@@ -0,0 +1,107 @@
+"""Shared pytest fixtures for cnb-tools tests."""
+
+import os
+import sys
+from unittest.mock import MagicMock
+
+import pandas as pd
+import pytest
+from synapseclient import Evaluation, SubmissionStatus
+
+
+def pytest_configure(config):
+    """Allow test scripts to import scripts from parent folder."""
+    src_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    sys.path.insert(0, src_path)
+
+
+@pytest.fixture
+def mock_syn():
+    """Fixture for mocked Synapse client."""
+    return MagicMock()
+
+
+@pytest.fixture
+def mock_submission_status():
+    """Fixture for mocked SubmissionStatus."""
+    status = MagicMock(spec=SubmissionStatus)
+    status.status = "SCORED"
+    status.submissionAnnotations = MagicMock()
+    status.submissionAnnotations.__getitem__ = lambda self, key: {
+        "score": 0.95,
+        "passed": True,
+    }.get(key)
+    return status
+
+
+@pytest.fixture
+def mock_submission_file():
+    """Fixture for mocked file submission."""
+    sub = MagicMock()
+    sub.id = "12345"
+    sub.evaluationId = "98765"
+    sub.createdOn = "2025-11-26T10:30:00.000Z"
+    sub.get.side_effect = lambda key: {"teamId": 111, "userId": 222}.get(key)
+    return sub
+
+
+@pytest.fixture
+def mock_submission_docker():
+    """Fixture for mocked Docker submission."""
+    sub = MagicMock()
+    sub.id = "12345"
+    sub.evaluationId = "98765"
+    sub.dockerRepositoryName = "docker.synapse.org/syn12345/model"
+    sub.dockerDigest = "sha256:abc123"
+    sub.__contains__ = lambda self, key: key == "dockerDigest"
+    return sub
+
+
+@pytest.fixture
+def mock_evaluation():
+    """Fixture for mocked Evaluation."""
+    eval_obj = MagicMock(spec=Evaluation)
+    eval_obj.id = "98765"
+    eval_obj.name = "Test Queue"
+    eval_obj.contentSource = "syn12345"
+    return eval_obj
+
+
+@pytest.fixture
+def truth_ids():
+    """Fixture for truth IDs."""
+    return pd.Series(["id1", "id2", "id3"], name="ids")
+
+
+@pytest.fixture
+def pred_ids_valid():
+    """Fixture for valid prediction IDs."""
+    return pd.Series(["id1", "id2", "id3"], name="ids")
+
+
+@pytest.fixture
+def pred_ids_invalid():
+    """Fixture for invalid prediction IDs."""
+    return pd.Series(["id1", "id1", "id4"], name="ids")
+
+
+@pytest.fixture
+def pred_values_valid():
+    """Fixture for valid prediction values."""
+    return pd.DataFrame(
+        {
+            "predictions": [0, 1, 1],
+            "probabilities": [0.25, 0.6, 0.83],
+        }
+    )
+
+
+@pytest.fixture
+def pred_values_invalid():
+    """Fixture for invalid prediction values."""
+    return pd.DataFrame(
+        {
+            "predictions": [0, 1, None],
+            "probabilities": [-0.5, 1.0, 1.5],
+        }
+    )

tests/conftest.py

@@ -0,0 +1,137 @@
+"""Unit tests for cnb_tools.modules.annotation"""
+
+from unittest.mock import MagicMock, Mock, mock_open, patch
+
+import pytest
+from synapseclient.core.exceptions import SynapseHTTPError
+
+from cnb_tools.modules import annotation
+from cnb_tools.modules.base import UnknownSynapseID
+
+
+class TestGetSubmissionStatus:
+    """Tests for get_submission_status function"""
+
+    @patch("cnb_tools.modules.annotation.get_synapse_client")
+    def test_get_submission_status_success(
+        self, mock_get_client, mock_syn, mock_submission_status
+    ):
+        """Test successfully getting submission status"""
+        mock_get_client.return_value = mock_syn
+        mock_syn.getSubmissionStatus.return_value = mock_submission_status
+
+        result = annotation.get_submission_status(12345)
+
+        mock_syn.getSubmissionStatus.assert_called_once_with(12345)
+        assert result == mock_submission_status
+
+    @patch("cnb_tools.modules.annotation.get_synapse_client")
+    def test_get_submission_status_invalid_id(self, mock_get_client, mock_syn):
+        """Test error handling for invalid submission ID"""
+        mock_get_client.return_value = mock_syn
+        mock_response = Mock()
+        mock_response.json.return_value = {"reason": "Submission not found"}
+        mock_syn.getSubmissionStatus.side_effect = SynapseHTTPError(
+            response=mock_response
+        )
+
+        with pytest.raises(UnknownSynapseID) as exc_info:
+            annotation.get_submission_status(99999)
+        assert "Submission not found" in str(exc_info.value)
+
+
+class TestUpdateAnnotations:
+    """Tests for update_annotations function"""
+
+    @patch("cnb_tools.modules.annotation.get_synapse_client")
+    @patch("cnb_tools.modules.annotation.get_submission_status")
+    def test_update_annotations_success(
+        self, mock_get_status, mock_get_client, mock_syn, mock_submission_status, capsys
+    ):
+        """Test successfully updating annotations"""
+        mock_get_client.return_value = mock_syn
+        mock_get_status.return_value = mock_submission_status
+        mock_syn.store.return_value = mock_submission_status
+
+        # Mock the submissionAnnotations attribute as a dictionary
+        mock_submission_status.submissionAnnotations = MagicMock()
+
+        new_annots = {"new_field": "value"}
+        result = annotation.update_annotations(12345, new_annots, verbose=False)
+
+        mock_submission_status.submissionAnnotations.update.assert_called_once_with(
+            new_annots
+        )
+        mock_syn.store.assert_called_once_with(mock_submission_status)
+
+        captured = capsys.readouterr()
+        assert "Submission ID 12345 annotations updated" in captured.out
+        assert result == mock_submission_status
+
+    @patch("cnb_tools.modules.annotation.get_synapse_client")
+    @patch("cnb_tools.modules.annotation.get_submission_status")
+    def test_update_annotations_verbose(
+        self, mock_get_status, mock_get_client, mock_syn, mock_submission_status, capsys
+    ):
+        """Test updating annotations with verbose output"""
+        mock_get_client.return_value = mock_syn
+        mock_get_status.return_value = mock_submission_status
+        mock_syn.store.return_value = mock_submission_status
+
+        # Mock submissionAnnotations as a dict for JSON serialization
+        mock_submission_status.submissionAnnotations = {"score": 0.95, "passed": True}
+
+        annotation.update_annotations(12345, {"test": "value"}, verbose=True)
+
+        captured = capsys.readouterr()
+        assert "Annotations:" in captured.out
+        assert "score" in captured.out
+
+
+class TestUpdateAnnotationsFromFile:
+    """Tests for update_annotations_from_file function"""
+
+    @patch("cnb_tools.modules.annotation.with_retry")
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data='{"score": 0.85, "status": "pass", "null_field": null, "empty_list": []}',
+    )
+    def test_update_annotations_from_file(self, mock_file, mock_retry):
+        """Test updating annotations from JSON file"""
+        mock_retry.return_value = MagicMock()
+
+        annotation.update_annotations_from_file(12345, "test.json", verbose=False)
+
+        mock_file.assert_called_once_with("test.json", encoding="utf-8")
+
+        # Verify with_retry was called
+        assert mock_retry.called
+
+        # Verify null and empty list values were filtered
+        call_args = mock_retry.call_args
+        assert call_args[1]["wait"] == 3
+        assert call_args[1]["retries"] == 10
+
+
+class TestUpdateSubmissionStatus:
+    """Tests for update_submission_status function"""
+
+    @patch("cnb_tools.modules.annotation.get_synapse_client")
+    @patch("cnb_tools.modules.annotation.get_submission_status")
+    def test_update_submission_status(
+        self, mock_get_status, mock_get_client, mock_syn, mock_submission_status, capsys
+    ):
+        """Test updating submission status"""
+        mock_get_client.return_value = mock_syn
+        mock_get_status.return_value = mock_submission_status
+        mock_syn.store.return_value = mock_submission_status
+
+        result = annotation.update_submission_status(12345, "ACCEPTED")
+
+        assert mock_submission_status.status == "ACCEPTED"
+        mock_syn.store.assert_called_once_with(mock_submission_status)
+
+        captured = capsys.readouterr()
+        assert "Updated submission ID 12345 to status: ACCEPTED" in captured.out
+        assert result == mock_submission_status

tests/test_annotation.py

@@ -0,0 +1,91 @@
+"""Unit tests for cnb_tools.modules.participant"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from synapseclient import Team
+from synapseclient.core.exceptions import SynapseHTTPError
+
+from cnb_tools.modules import participant
+
+
+class TestGetParticipantName:
+    """Tests for get_participant_name function"""
+
+    @patch("cnb_tools.modules.participant.get_synapse_client")
+    def test_get_participant_name_team(self, mock_get_client, mock_syn):
+        """Test getting team name"""
+        mock_get_client.return_value = mock_syn
+        mock_syn.getTeam.return_value = {"name": "Dream Team"}
+
+        result = participant.get_participant_name(12345)
+
+        assert result == "Dream Team"
+        mock_syn.getTeam.assert_called_once_with(12345)
+
+    @patch("cnb_tools.modules.participant.get_synapse_client")
+    def test_get_participant_name_user(self, mock_get_client, mock_syn):
+        """Test getting username when team lookup fails"""
+        mock_get_client.return_value = mock_syn
+        mock_syn.getTeam.side_effect = SynapseHTTPError(response=MagicMock())
+        mock_syn.getUserProfile.return_value = {"userName": "john_doe"}
+
+        result = participant.get_participant_name(67890)
+
+        assert result == "john_doe"
+        mock_syn.getUserProfile.assert_called_once_with(67890)
+
+
+class TestCreateTeam:
+    """Tests for create_team function"""
+
+    @patch("cnb_tools.modules.participant.typer.confirm")
+    @patch("cnb_tools.modules.participant.get_synapse_client")
+    def test_create_team_new(self, mock_get_client, mock_confirm, mock_syn):
+        """Test creating a new team"""
+        mock_get_client.return_value = mock_syn
+        mock_syn.getTeam.side_effect = ValueError("Team not found")
+
+        result = participant.create_team(
+            name="New Team", description="Test description", can_public_join=True
+        )
+
+        assert isinstance(result, Team)
+        assert result.name == "New Team"
+        assert result.description == "Test description"
+        assert result.canPublicJoin is True
+
+    @patch("cnb_tools.modules.participant.typer.confirm")
+    @patch("cnb_tools.modules.participant.get_synapse_client")
+    def test_create_team_existing_confirmed(
+        self, mock_get_client, mock_confirm, mock_syn
+    ):
+        """Test using an existing team when user confirms"""
+        mock_get_client.return_value = mock_syn
+        existing_team = MagicMock(spec=Team)
+        existing_team.name = "Dream Team"
+        mock_syn.getTeam.return_value = existing_team
+        mock_confirm.return_value = True
+
+        result = participant.create_team(name="Dream Team")
+
+        assert result == existing_team
+        mock_confirm.assert_called_once_with(
+            "Team 'Dream Team' already exists. Use this team?"
+        )
+
+    @patch("cnb_tools.modules.participant.typer.confirm")
+    @patch("cnb_tools.modules.participant.get_synapse_client")
+    def test_create_team_existing_declined(
+        self, mock_get_client, mock_confirm, mock_syn
+    ):
+        """Test declining to use existing team exits"""
+        mock_get_client.return_value = mock_syn
+        existing_team = MagicMock(spec=Team)
+        mock_syn.getTeam.return_value = existing_team
+        mock_confirm.return_value = False
+
+        with pytest.raises(SystemExit) as exc_info:
+            participant.create_team(name="Existing Team")
+
+        assert "Try again with a new challenge name" in str(exc_info.value)