mirror of
https://github.com/MadsLorentzen/ai-job-search.git
synced 2026-09-17 16:46:24 +00:00
382 lines
14 KiB
Python
382 lines
14 KiB
Python
"""Tests for salary_lookup.py — format_entry, match_score, and search_company."""
|
|
|
|
import io
|
|
import tempfile
|
|
import unittest
|
|
from contextlib import redirect_stderr
|
|
from pathlib import Path
|
|
|
|
import salary_lookup
|
|
from salary_lookup import (
|
|
format_entry,
|
|
normalize,
|
|
anglicize,
|
|
extract_core_words,
|
|
match_score,
|
|
search_company,
|
|
validate_data,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# format_entry tests (from #75 / #98)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class FormatEntryTests(unittest.TestCase):
|
|
def test_zero_count_is_displayed_as_zero(self):
|
|
entry = {
|
|
"company": "Example Corp",
|
|
"city": "",
|
|
"categories": {
|
|
"public_data": {
|
|
"count": 0,
|
|
"index": 100.0,
|
|
},
|
|
},
|
|
}
|
|
|
|
rendered = format_entry(entry, {"index_baseline": 100, "index_label": "Index"})
|
|
|
|
self.assertRegex(rendered, r"Public Data\s+0\s+100\.0")
|
|
|
|
def test_text_index_does_not_crash(self):
|
|
entry = {
|
|
"company": "Example Corp",
|
|
"city": "",
|
|
"categories": {
|
|
"sample": {
|
|
"count": 3,
|
|
"index": "private",
|
|
},
|
|
},
|
|
}
|
|
|
|
rendered = format_entry(entry, {"index_baseline": 100, "index_label": "Index"})
|
|
|
|
self.assertIn("private", rendered)
|
|
|
|
def test_format_entry_with_zero_baseline(self):
|
|
entry = {
|
|
"company": "Example Corp",
|
|
"city": "",
|
|
"categories": {
|
|
"it": {
|
|
"count": None,
|
|
"index": 45000.0,
|
|
},
|
|
},
|
|
}
|
|
rendered = format_entry(entry, {"index_baseline": 0, "index_label": "Salary"})
|
|
self.assertIn("45000.0", rendered)
|
|
self.assertNotIn("%", rendered)
|
|
|
|
def test_format_entry_with_custom_baseline(self):
|
|
entry = {
|
|
"company": "Example Corp",
|
|
"city": "",
|
|
"categories": {
|
|
"it": {
|
|
"count": None,
|
|
"index": 45000.0,
|
|
},
|
|
},
|
|
}
|
|
rendered = format_entry(entry, {"index_baseline": 40000, "index_label": "Salary"})
|
|
self.assertIn("45000.0", rendered)
|
|
self.assertIn("+12.5%", rendered)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# match_score tests (from #106)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestMatchScoreExactMatch(unittest.TestCase):
|
|
def test_exact_match_returns_100(self):
|
|
self.assertEqual(match_score("Novo Nordisk", "Novo Nordisk"), 100)
|
|
|
|
def test_exact_match_case_insensitive(self):
|
|
self.assertEqual(match_score("NOVO NORDISK", "Novo Nordisk"), 100)
|
|
|
|
def test_exact_match_after_suffix_stripping(self):
|
|
self.assertEqual(match_score("Mærsk", "Mærsk A/S"), 100)
|
|
|
|
|
|
class TestMatchScoreSubstring(unittest.TestCase):
|
|
def test_query_contained_in_entry_gives_high_score(self):
|
|
score = match_score("Carlsberg", "Carlsberg Danmark A/S")
|
|
self.assertGreaterEqual(score, 80)
|
|
|
|
def test_entry_contained_in_query_gives_high_score(self):
|
|
score = match_score("Carlsberg Danmark", "Carlsberg")
|
|
self.assertGreaterEqual(score, 80)
|
|
|
|
|
|
class TestMatchScoreShortQuery(unittest.TestCase):
|
|
def test_short_query_no_word_overlap_returns_zero(self):
|
|
score = match_score("ab", "Something Unrelated Company")
|
|
self.assertEqual(score, 0)
|
|
|
|
def test_short_query_with_word_overlap_scores(self):
|
|
score = match_score("IBM", "IBM Corporation")
|
|
self.assertGreater(score, 0)
|
|
|
|
|
|
class TestMatchScoreAnglicize(unittest.TestCase):
|
|
def test_oe_variant_matches_o_with_slash(self):
|
|
score = match_score("Maersk", "Mærsk A/S")
|
|
self.assertGreater(score, 0)
|
|
|
|
def test_aa_variant_matches_aa(self):
|
|
self.assertEqual(match_score("Aarsleff", "Aarsleff"), 100)
|
|
|
|
def test_danish_characters_roundtrip(self):
|
|
score = match_score("Maersk", "Mærsk A/S")
|
|
self.assertGreater(score, 0)
|
|
|
|
|
|
class TestMatchScoreNoOverlap(unittest.TestCase):
|
|
def test_completely_unrelated_names_return_zero(self):
|
|
self.assertEqual(match_score("Apple", "Vestas Wind Systems"), 0)
|
|
|
|
def test_empty_query_returns_zero(self):
|
|
self.assertEqual(match_score("", "Novo Nordisk"), 0)
|
|
|
|
def test_empty_entry_returns_zero(self):
|
|
self.assertEqual(match_score("Novo Nordisk", ""), 0)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# search_company tests (from #75 / #98 and #106)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _make_data(*entries):
|
|
return {"companies": list(entries)}
|
|
|
|
|
|
def _entry(company, city=""):
|
|
return {"company": company, "city": city}
|
|
|
|
|
|
class SearchCompanyTests(unittest.TestCase):
|
|
def test_search_company_with_none_city(self):
|
|
data = {
|
|
"companies": [
|
|
{
|
|
"company": "Acme",
|
|
"city": None,
|
|
}
|
|
]
|
|
}
|
|
results = search_company(data, "Acme", city="Aarhus")
|
|
self.assertEqual(results, [])
|
|
|
|
|
|
class ValidateDataTests(unittest.TestCase):
|
|
def assert_invalid_data(self, data, expected_message):
|
|
stderr = io.StringIO()
|
|
with self.assertRaises(SystemExit) as raised:
|
|
with redirect_stderr(stderr):
|
|
validate_data(data)
|
|
|
|
self.assertEqual(raised.exception.code, 1)
|
|
self.assertIn("Error: invalid salary_data.json", stderr.getvalue())
|
|
self.assertIn(expected_message, stderr.getvalue())
|
|
self.assertIn("tools/README_SALARY_TOOL.md", stderr.getvalue())
|
|
|
|
def test_valid_minimal_data_is_returned(self):
|
|
data = {"metadata": {}, "companies": [{"company": "Example Corp"}]}
|
|
|
|
self.assertIs(validate_data(data), data)
|
|
|
|
def test_top_level_value_must_be_object(self):
|
|
self.assert_invalid_data([], "top-level JSON value must be an object")
|
|
|
|
def test_companies_must_be_list(self):
|
|
self.assert_invalid_data({"companies": {"company": "Example Corp"}}, "'companies' must be a list")
|
|
|
|
def test_metadata_must_be_object_when_provided(self):
|
|
self.assert_invalid_data(
|
|
{"metadata": [], "companies": [{"company": "Example Corp"}]},
|
|
"'metadata' must be an object when provided",
|
|
)
|
|
|
|
def test_load_data_reports_json_parse_errors_without_traceback(self):
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
data_file = Path(tmpdir) / "salary_data.json"
|
|
data_file.write_text('{"companies": [', encoding="utf-8")
|
|
|
|
original_data_file = salary_lookup.DATA_FILE
|
|
salary_lookup.DATA_FILE = data_file
|
|
try:
|
|
stderr = io.StringIO()
|
|
with self.assertRaises(SystemExit) as raised:
|
|
with redirect_stderr(stderr):
|
|
salary_lookup.load_data()
|
|
finally:
|
|
salary_lookup.DATA_FILE = original_data_file
|
|
|
|
self.assertEqual(raised.exception.code, 1)
|
|
self.assertIn("invalid JSON at line", stderr.getvalue())
|
|
self.assertIn("tools/README_SALARY_TOOL.md", stderr.getvalue())
|
|
|
|
def test_company_entry_must_be_object(self):
|
|
self.assert_invalid_data({"companies": ["Example Corp"]}, "companies[1] must be an object")
|
|
|
|
def test_company_name_is_required(self):
|
|
self.assert_invalid_data({"companies": [{"city": "Aarhus"}]}, "companies[1].company must be a non-empty string")
|
|
|
|
def test_company_name_must_not_be_blank(self):
|
|
self.assert_invalid_data({"companies": [{"company": " "}]}, "companies[1].company must be a non-empty string")
|
|
|
|
def test_city_must_be_string_when_provided(self):
|
|
self.assert_invalid_data(
|
|
{"companies": [{"company": "Example Corp", "city": 123}]},
|
|
"companies[1].city must be a string when provided",
|
|
)
|
|
|
|
def test_categories_must_be_object_when_provided(self):
|
|
self.assert_invalid_data(
|
|
{"companies": [{"company": "Example Corp", "categories": []}]},
|
|
"companies[1].categories must be an object when provided",
|
|
)
|
|
|
|
|
|
class UtilityTests(unittest.TestCase):
|
|
def test_normalize_strips_suffix_and_noise(self):
|
|
self.assertEqual(normalize("Novo Nordisk A/S"), "novonordisk")
|
|
self.assertEqual(normalize("Ørsted (VG) Holding"), "ørsted")
|
|
self.assertEqual(normalize("Chr. Hansen, Denmark Division"), "chrhansen")
|
|
self.assertEqual(normalize("Simple Corp ApS"), "simplecorp")
|
|
|
|
def test_anglicize_replaces_danish_chars(self):
|
|
self.assertEqual(anglicize("ørsted"), "orsted")
|
|
self.assertEqual(anglicize("mærsk"), "maersk")
|
|
self.assertEqual(anglicize("ålborg"), "aalborg")
|
|
|
|
def test_extract_core_words(self):
|
|
self.assertEqual(extract_core_words("Novo Nordisk A/S"), ["novo", "nordisk"])
|
|
self.assertEqual(extract_core_words("A/S"), [])
|
|
self.assertEqual(extract_core_words("Test Company (Sub-entity)"), ["test", "company"])
|
|
|
|
|
|
class MatchScoreTests(unittest.TestCase):
|
|
def test_exact_match_score(self):
|
|
self.assertEqual(match_score("Novo Nordisk", "Novo Nordisk"), 100)
|
|
self.assertEqual(match_score("novo nordisk", "Novo Nordisk A/S"), 100)
|
|
|
|
def test_partial_match_score(self):
|
|
self.assertGreater(match_score("Novo", "Novo Nordisk A/S"), 80)
|
|
self.assertEqual(match_score("Novo Nordisk", "Novo"), 75)
|
|
|
|
def test_anglicized_match_score(self):
|
|
self.assertEqual(match_score("Orsted", "Ørsted A/S"), 85)
|
|
|
|
def test_overlap_match_score(self):
|
|
# Overlap of multiple words
|
|
self.assertGreater(match_score("Novo Tech", "Novo Nordisk Tech A/S"), 30)
|
|
|
|
def test_no_match_score(self):
|
|
self.assertEqual(match_score("Google", "Microsoft"), 0)
|
|
|
|
|
|
class SearchCompanyRefactoredTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.data = {
|
|
"companies": [
|
|
{"company": "Novo Nordisk A/S", "city": "Bagsværd"},
|
|
{"company": "Ørsted", "city": "Fredericia"},
|
|
{"company": "Vestas Wind Systems", "city": "Aarhus"},
|
|
]
|
|
}
|
|
|
|
def test_search_by_name(self):
|
|
results = search_company(self.data, "Novo")
|
|
self.assertEqual(len(results), 1)
|
|
self.assertEqual(results[0]["company"], "Novo Nordisk A/S")
|
|
|
|
def test_search_with_city_filter(self):
|
|
results = search_company(self.data, "Ørsted", city="Fredericia")
|
|
self.assertEqual(len(results), 1)
|
|
|
|
# Mismatching city
|
|
results_wrong_city = search_company(self.data, "Ørsted", city="Bagsværd")
|
|
self.assertEqual(len(results_wrong_city), 0)
|
|
|
|
|
|
class TestSearchCompanyBasicMatch(unittest.TestCase):
|
|
def test_exact_name_returns_match(self):
|
|
data = _make_data(_entry("Novo Nordisk", "Bagsværd"))
|
|
results = search_company(data, "Novo Nordisk")
|
|
self.assertEqual(len(results), 1)
|
|
self.assertEqual(results[0]["company"], "Novo Nordisk")
|
|
|
|
def test_no_match_returns_empty_list(self):
|
|
data = _make_data(_entry("Vestas Wind Systems", "Aarhus"))
|
|
results = search_company(data, "Apple")
|
|
self.assertEqual(results, [])
|
|
|
|
def test_multiple_candidates_all_returned(self):
|
|
data = _make_data(
|
|
_entry("Carlsberg A/S", "Copenhagen"),
|
|
_entry("Carlsberg Danmark", "Fredericia"),
|
|
_entry("Unrelated Corp", "Odense"),
|
|
)
|
|
results = search_company(data, "Carlsberg")
|
|
companies = [r["company"] for r in results]
|
|
self.assertIn("Carlsberg A/S", companies)
|
|
self.assertIn("Carlsberg Danmark", companies)
|
|
self.assertNotIn("Unrelated Corp", companies)
|
|
|
|
|
|
class TestSearchCompanyCityFilter(unittest.TestCase):
|
|
def test_matching_city_is_included(self):
|
|
data = _make_data(
|
|
_entry("Novo Nordisk", "Bagsværd"),
|
|
_entry("Novo Nordisk", "Aarhus"),
|
|
)
|
|
results = search_company(data, "Novo Nordisk", city="Aarhus")
|
|
self.assertEqual(len(results), 1)
|
|
self.assertEqual(results[0]["city"], "Aarhus")
|
|
|
|
def test_non_matching_city_is_excluded(self):
|
|
data = _make_data(_entry("Novo Nordisk", "Bagsværd"))
|
|
results = search_company(data, "Novo Nordisk", city="Odense")
|
|
self.assertEqual(results, [])
|
|
|
|
def test_no_city_filter_returns_all_cities(self):
|
|
data = _make_data(
|
|
_entry("Novo Nordisk", "Bagsværd"),
|
|
_entry("Novo Nordisk", "Aarhus"),
|
|
)
|
|
results = search_company(data, "Novo Nordisk")
|
|
self.assertEqual(len(results), 2)
|
|
|
|
def test_city_filter_case_insensitive(self):
|
|
data = _make_data(_entry("Novo Nordisk", "København"))
|
|
results = search_company(data, "Novo Nordisk", city="københavn")
|
|
self.assertEqual(len(results), 1)
|
|
|
|
def test_anglicized_city_matches_danish_city(self):
|
|
data = _make_data(_entry("Novo Nordisk", "København"))
|
|
results = search_company(data, "Novo Nordisk", city="kobenhavn")
|
|
self.assertEqual(len(results), 1)
|
|
|
|
|
|
class TestSearchCompanyScoreThreshold(unittest.TestCase):
|
|
def test_low_score_matches_excluded(self):
|
|
data = _make_data(_entry("Novo Nordisk", "Bagsværd"))
|
|
results = search_company(data, "xyz")
|
|
self.assertEqual(results, [])
|
|
|
|
def test_results_sorted_by_relevance_descending(self):
|
|
data = _make_data(
|
|
_entry("Novo Nordisk International", "Bagsværd"),
|
|
_entry("Novo Nordisk", "Bagsværd"),
|
|
)
|
|
results = search_company(data, "Novo Nordisk")
|
|
self.assertEqual(results[0]["company"], "Novo Nordisk")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|