refactor: match upstream unittest convention

Convert all new tests from bare pytest style to unittest.TestCase
with sys.path.insert, matching the convention used by all existing
tests. Remove pyproject.toml and conftest.py.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/test_reddit_sc.py

@@ -1,59 +1,66 @@
 """Tests for reddit.py — ScrapeCreators Reddit search module."""
 
+import sys
+import unittest
+from pathlib import Path
+
+# Add lib to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "scripts"))
+
 from lib import reddit
 
 
-class TestExtractCoreSubject:
+class TestExtractCoreSubject(unittest.TestCase):
     """Tests for _extract_core_subject()."""
 
     def test_strips_what_are_prefix(self):
-        assert reddit._extract_core_subject("what are the best AI tools") == "ai tools"
+        self.assertEqual(reddit._extract_core_subject("what are the best AI tools"), "ai tools")
 
     def test_strips_how_to_prefix(self):
-        assert reddit._extract_core_subject("how to use cursor IDE") == "cursor ide"
+        self.assertEqual(reddit._extract_core_subject("how to use cursor IDE"), "cursor ide")
 
     def test_strips_noise_words(self):
         result = reddit._extract_core_subject("latest trending updates")
-        assert result == "latest trending updates"
+        self.assertEqual(result, "latest trending updates")
 
     def test_preserves_product_name(self):
-        assert reddit._extract_core_subject("cursor IDE") == "cursor ide"
+        self.assertEqual(reddit._extract_core_subject("cursor IDE"), "cursor ide")
 
     def test_strips_trailing_punctuation(self):
         result = reddit._extract_core_subject("what is Claude?")
-        assert not result.endswith("?")
+        self.assertFalse(result.endswith("?"))
 
     def test_empty_string(self):
         result = reddit._extract_core_subject("")
-        assert result == ""
+        self.assertEqual(result, "")
 
     def test_strips_what_do_people_think(self):
         result = reddit._extract_core_subject("what do people think about React Server Components")
-        assert result == "react server components"
+        self.assertEqual(result, "react server components")
 
 
-class TestExpandRedditQueries:
+class TestExpandRedditQueries(unittest.TestCase):
     """Tests for expand_reddit_queries()."""
 
     def test_quick_returns_one_query(self):
         queries = reddit.expand_reddit_queries("cursor IDE", "quick")
-        assert len(queries) >= 1
+        self.assertGreaterEqual(len(queries), 1)
 
     def test_default_includes_review_variant(self):
         queries = reddit.expand_reddit_queries("cursor IDE", "default")
-        assert any("worth it" in q or "review" in q for q in queries)
+        self.assertTrue(any("worth it" in q or "review" in q for q in queries))
 
     def test_deep_includes_issues_variant(self):
         queries = reddit.expand_reddit_queries("cursor IDE", "deep")
-        assert any("issues" in q or "problems" in q for q in queries)
+        self.assertTrue(any("issues" in q or "problems" in q for q in queries))
 
     def test_deep_has_more_queries_than_quick(self):
         quick = reddit.expand_reddit_queries("cursor IDE", "quick")
         deep = reddit.expand_reddit_queries("cursor IDE", "deep")
-        assert len(deep) > len(quick)
+        self.assertGreater(len(deep), len(quick))
 
 
-class TestDiscoverSubreddits:
+class TestDiscoverSubreddits(unittest.TestCase):
     """Tests for discover_subreddits()."""
 
     def test_ranks_by_frequency(self):
@@ -63,7 +70,7 @@ class TestDiscoverSubreddits:
             {"subreddit": "python", "score": 5},
         ]
         subs = reddit.discover_subreddits(results, max_subs=5)
-        assert subs[0] == "programming"
+        self.assertEqual(subs[0], "programming")
 
     def test_utility_sub_penalty(self):
         results = [
@@ -72,7 +79,7 @@ class TestDiscoverSubreddits:
             {"subreddit": "python", "score": 10},
         ]
         subs = reddit.discover_subreddits(results, topic="python", max_subs=5)
-        assert subs[0] == "python"
+        self.assertEqual(subs[0], "python")
 
     def test_topic_name_bonus(self):
         results = [
@@ -80,7 +87,7 @@ class TestDiscoverSubreddits:
             {"subreddit": "webdev", "score": 10},
         ]
         subs = reddit.discover_subreddits(results, topic="react hooks", max_subs=5)
-        assert subs[0] == "reactjs"
+        self.assertEqual(subs[0], "reactjs")
 
     def test_engagement_bonus(self):
         results = [
@@ -88,48 +95,56 @@ class TestDiscoverSubreddits:
             {"subreddit": "OtherSub", "ups": 5},
         ]
         subs = reddit.discover_subreddits(results, max_subs=5)
-        assert subs[0] == "AIsub"
+        self.assertEqual(subs[0], "AIsub")
 
     def test_max_subs_limit(self):
         results = [{"subreddit": f"sub{i}"} for i in range(20)]
         subs = reddit.discover_subreddits(results, max_subs=3)
-        assert len(subs) <= 3
+        self.assertLessEqual(len(subs), 3)
 
     def test_empty_results(self):
-        assert reddit.discover_subreddits([]) == []
+        self.assertEqual(reddit.discover_subreddits([]), [])
 
     def test_missing_subreddit_field(self):
         results = [{"title": "no sub field"}]
-        assert reddit.discover_subreddits(results) == []
+        self.assertEqual(reddit.discover_subreddits(results), [])
 
 
-class TestParseDate:
+class TestParseDate(unittest.TestCase):
     """Tests for _parse_date()."""
 
     def test_valid_timestamp(self):
-        assert reddit._parse_date(1705363200) == "2024-01-16"
+        self.assertEqual(reddit._parse_date(1705363200), "2024-01-16")
 
     def test_string_timestamp(self):
-        assert reddit._parse_date("1705363200") == "2024-01-16"
+        self.assertEqual(reddit._parse_date("1705363200"), "2024-01-16")
 
     def test_none_returns_none(self):
-        assert reddit._parse_date(None) is None
+        self.assertIsNone(reddit._parse_date(None))
 
     def test_zero_returns_none(self):
-        assert reddit._parse_date(0) is None
+        self.assertIsNone(reddit._parse_date(0))
 
 
-class TestDepthConfig:
+class TestDepthConfig(unittest.TestCase):
     """Tests for DEPTH_CONFIG structure."""
 
     def test_all_depths_exist(self):
         for depth in ("quick", "default", "deep"):
-            assert depth in reddit.DEPTH_CONFIG
+            self.assertIn(depth, reddit.DEPTH_CONFIG)
 
     def test_required_keys(self):
         required = {"global_searches", "subreddit_searches", "comment_enrichments", "timeframe"}
         for depth, config in reddit.DEPTH_CONFIG.items():
-            assert required.issubset(config.keys()), f"Missing keys in {depth}: {required - config.keys()}"
+            self.assertTrue(required.issubset(config.keys()),
+                            f"Missing keys in {depth}: {required - config.keys()}")
 
     def test_deep_has_more_searches(self):
-        assert reddit.DEPTH_CONFIG["deep"]["global_searches"] > reddit.DEPTH_CONFIG["quick"]["global_searches"]
+        self.assertGreater(
+            reddit.DEPTH_CONFIG["deep"]["global_searches"],
+            reddit.DEPTH_CONFIG["quick"]["global_searches"],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()