fix: inconsistent use of to_dict and to_json

Author: chriswblake

openproficiency/ProficiencyScore.py

@@ -1,5 +1,6 @@
 """ProficiencyScore module for OpenProficiency library."""
 
+import json
 from enum import Enum
 from typing import Union
 
@@ -84,13 +85,17 @@ def _get_name_from_score(self, score: float) -> ProficiencyScoreName:
         else:
             raise ValueError(f"Invalid score value: {score}")
 
-    def to_json(self) -> dict:
+    def to_dict(self) -> dict:
         """Convert to a JSON-serializable dictionary."""
         return {
             "topic_id": self.topic_id,
             "score": self._score
         }
 
+    def to_json(self) -> str:
+        """Convert to a JSON string."""
+        return json.dumps(self.to_dict())
+
     # Debugging
 
     def __repr__(self) -> str:

openproficiency/Topic.py

@@ -1,5 +1,6 @@
 """Topic module for OpenProficiency library."""
 
+import json
 from typing import List, Union
 
 
@@ -77,7 +78,7 @@ def add_pretopics(self, pretopics: List[Union[str, "Topic"]]) -> None:
         for pretopic in pretopics:
             self.add_pretopic(pretopic)
 
-    def to_json(self) -> dict:
+    def to_dict(self) -> dict:
         """Convert Topic to JSON-serializable dictionary."""
         return {
             "id": self.id,
@@ -86,6 +87,10 @@ def to_json(self) -> dict:
             "pretopics": self.pretopics
         }
 
+    def to_json(self) -> str:
+        """Convert Topic to JSON string."""
+        return json.dumps(self.to_dict())
+
     # Debugging
     def __repr__(self) -> str:
         """String representation of Topic."""

openproficiency/TopicList.py

@@ -15,7 +15,7 @@ def __init__(
         owner: str,
         name: str,
         # Optional
-        description: str = "",
+        description: str = ""
     ):
         # Required
         self.owner = owner
@@ -204,7 +204,7 @@ def _add_pretopics_recursive(
                     topic_list.add_topic(pretopic)
                     current_child.add_pretopic(pretopic)
 
-    def to_json(self) -> str:
+    def to_dict(self) -> dict:
         """
         Export the TopicList to a JSON string.
         """
@@ -234,4 +234,8 @@ def to_json(self) -> str:
             # Store in data
             data["topics"][topic_id] = topic_data
 
-        return json.dumps(data, indent=2)
+        return data
+
+    def to_json(self) -> str:
+        """Convert TopicList to JSON string."""
+        return json.dumps(self.to_dict())

openproficiency/TranscriptEntry.py

@@ -1,5 +1,6 @@
 """TranscriptEntry module for OpenProficiency library."""
 
+import json
 from datetime import datetime
 from typing import Optional
 from .ProficiencyScore import ProficiencyScore
@@ -38,7 +39,7 @@ def proficiency_score(self) -> ProficiencyScore:
         return self._proficiency_score
 
     # Methods
-    def to_json(self) -> dict:
+    def to_dict(self) -> dict:
         """Convert Topic to JSON-serializable dictionary."""
         return {
             "user_id": self.user_id,
@@ -48,6 +49,10 @@ def to_json(self) -> dict:
             "timestamp": self.timestamp.isoformat()
         }
 
+    def to_json(self) -> str:
+        """Convert Topic to JSON string."""
+        return json.dumps(self.to_dict())
+
     # Debugging
     def __repr__(self) -> str:
         """String representation of TranscriptEntry."""

tests/ProficiencyScore_test.py

@@ -183,8 +183,7 @@ def test_score_name_setter_invalid_type(self):
             assert "ProficiencyScoreName enum" in str(e)
 
     # Methods
-
-    def test_to_json(self):
+    def test_to_dict(self):
         """Test conversion to JSON-serializable dictionary."""
 
         # Arrange
@@ -193,14 +192,29 @@ def test_to_json(self):
         ps = ProficiencyScore(topic_id=topic_id, score=score)
 
         # Act
-        json_dict = ps.to_json()
+        json_dict = ps.to_dict()
 
         # Assert
         assert json_dict == {
             "topic_id": topic_id,
             "score": score
         }
 
+    def test_to_json(self):
+        """Test conversion to JSON string."""
+
+        # Arrange
+        topic_id = "git-commit"
+        score = 0.8
+        ps = ProficiencyScore(topic_id=topic_id, score=score)
+
+        # Act
+        json_str = ps.to_json()
+
+        # Assert
+        expected_json = '{"topic_id": "git-commit", "score": 0.8}'
+        assert json_str == expected_json
+
     # Debugging
     def test_repr(self):
         """Test string representation of ProficiencyScore."""

tests/TopicList_test.py

@@ -374,25 +374,69 @@ def test_load_from_json_prepretopics(self):
         assert "git-pull" in topic_list.topics
         assert topic_list.topics["git-pull"].description == "Versioning code with Git repositories"
 
-    def test_to_json_simple(self):
-        """Exporting a simple TopicList to JSON."""
+    def test_to_dict_simple(self):
+        """Exporting a simple TopicList to dictionary."""
 
         # Arrange
         topic_list = TopicList(
             owner="github",
             name="github-features",
             description="Features of the GitHub platform",
         )
-        topic1 = Topic(id="actions", description="Storing changes to the Git history")
-        topic1.add_subtopic("automation")
-        topic1.add_pretopic("yaml")
+        topic_list.add_topic(Topic(
+            id="actions",
+            description="Storing changes to the Git history",
+            subtopics=["automation"],
+            pretopics=["yaml"]
+        ))
+        topic_list.add_topic(Topic(
+            id="repositories",
+            description="Versioning code with Git repositories",
+            subtopics=["git-clone"],
+            pretopics=["git-push"]
+        ))
 
-        topic2 = Topic(id="repositories", description="Versioning code with Git repositories")
-        topic2.add_subtopic("git-clone")
-        topic2.add_pretopic("git-push")
+        # Act
+        data = topic_list.to_dict()
 
-        topic_list.add_topic(topic1)
-        topic_list.add_topic(topic2)
+        # Assert - List Info
+        assert data["owner"] == "github"
+        assert data["name"] == "github-features"
+        assert data["description"] == "Features of the GitHub platform"
+
+        # Assert - Topic 1
+        assert "actions" in data["topics"]
+        assert data["topics"]["actions"]["description"] == "Storing changes to the Git history"
+        assert "automation" in data["topics"]["actions"]["subtopics"]
+        assert "yaml" in data["topics"]["actions"]["pretopics"]
+
+        # Assert - Topic 2
+        assert "repositories" in data["topics"]
+        assert data["topics"]["repositories"]["description"] == "Versioning code with Git repositories"
+        assert "git-clone" in data["topics"]["repositories"]["subtopics"]
+        assert "git-push" in data["topics"]["repositories"]["pretopics"]
+
+    def test_to_json_simple(self):
+        """Exporting a simple TopicList to JSON string."""
+
+        # Arrange
+        topic_list = TopicList(
+            owner="github",
+            name="github-features",
+            description="Features of the GitHub platform",
+        )
+        topic_list.add_topic(Topic(
+            id="actions",
+            description="Storing changes to the Git history",
+            subtopics=["automation"],
+            pretopics=["yaml"]
+        ))
+        topic_list.add_topic(Topic(
+            id="repositories",
+            description="Versioning code with Git repositories",
+            subtopics=["git-clone"],
+            pretopics=["git-push"]
+        ))
 
         # Act
         json_data = topic_list.to_json()

tests/Topic_test.py

@@ -1,3 +1,4 @@
+import json
 from openproficiency import Topic
 
 
@@ -141,7 +142,7 @@ def test_add_pretopics_mixed(self):
         assert pretopic1 in topic.pretopics
         assert pretopic2.id in topic.pretopics
 
-    def test_to_json(self):
+    def test_to_dict(self):
         """Test converting a Topic to JSON."""
 
         # Arrange
@@ -153,7 +154,29 @@ def test_to_json(self):
         )
 
         # Act
-        topic_json = topic.to_json()
+        topic_json = topic.to_dict()
+
+        # Assert
+        assert topic_json["id"] == "git-merge"
+        assert topic_json["description"] == "Combining branches in Git"
+        assert "git-branch" in topic_json["subtopics"]
+        assert "git-commit" in topic_json["subtopics"]
+        assert "cli" in topic_json["pretopics"]
+
+    def test_to_json(self):
+        """Test converting a Topic to JSON string."""
+
+        # Arrange
+        topic = Topic(
+            id="git-merge",
+            description="Combining branches in Git",
+            subtopics=["git-branch", "git-commit"],
+            pretopics=["cli"]
+        )
+
+        # Act
+        topic_json_str = topic.to_json()
+        topic_json = json.loads(topic_json_str)
 
         # Assert
         assert topic_json["id"] == "git-merge"

tests/TranscriptEntry_test.py

@@ -96,6 +96,54 @@ def test_proficiency_score(self):
         assert topic_id == "git-commit"
         assert score == 0.8
 
+    # Methods
+    def test_to_dict(self):
+        """Test conversion of TranscriptEntry to dictionary."""
+
+        # Arrange
+        entry = TranscriptEntry(
+            user_id="user-123",
+            topic_id="git-commit",
+            score=0.8,
+            issuer="github-learn",
+            timestamp=datetime(2024, 1, 15, 10, 30, 0)
+        )
+
+        # Act
+        entry_dict = entry.to_dict()
+
+        # Assert
+        assert entry_dict == {
+            "user_id": "user-123",
+            "topic_id": "git-commit",
+            "score": 0.8,
+            "issuer": "github-learn",
+            "timestamp": "2024-01-15T10:30:00"
+        }
+
+    def test_to_json(self):
+        """Test conversion of TranscriptEntry to JSON string."""
+
+        # Arrange
+        entry = TranscriptEntry(
+            user_id="user-123",
+            topic_id="git-commit",
+            score=0.8,
+            issuer="github-learn",
+            timestamp=datetime(2024, 1, 15, 10, 30, 0)
+        )
+
+        # Act
+        json_str = entry.to_json()
+
+        # Assert
+        expected_json = (
+            '{"user_id": "user-123", "topic_id": "git-commit", '
+            '"score": 0.8, "issuer": "github-learn", '
+            '"timestamp": "2024-01-15T10:30:00"}'
+        )
+        assert json_str == expected_json
+
     # Debugging
     def test_repr(self):
         """Test string representation of TranscriptEntry."""