226 lines
10 KiB
Python
226 lines
10 KiB
Python
import unittest
|
|
from pathlib import Path
|
|
# from convert_to_sportspress
|
|
from src.utils.common import validate_csv_header, normalize_header_key, read_and_normalize_csv_or_xlsx, parse_score, is_visitor_home_order_reversed, import_gamebygame, aggregate_teams
|
|
from src.utils.normalize import normalize_value, normalize_header_key, load_config
|
|
import toml
|
|
|
|
class TestConvertToSportsPress(unittest.TestCase):
|
|
def setUp(self):
|
|
# Path to the test CSV file
|
|
self.test_csv_path_2009 = Path("data/2009.csv")
|
|
|
|
def test_validate_csv_header(self):
|
|
header = ["Date", "Time", "Field", "Visitor", "Home", "Results", "Results"]
|
|
self.assertTrue(validate_csv_header(header))
|
|
header = ["Time", "Field", "Visitor", "Home", "Results", "Results"]
|
|
self.assertFalse(validate_csv_header(header))
|
|
|
|
def test_normalize_header_key(self):
|
|
self.assertEqual(normalize_header_key("Away"), "visitor")
|
|
self.assertEqual(normalize_header_key("Visitor"), "visitor")
|
|
self.assertEqual(normalize_header_key("Results"), "results")
|
|
self.assertEqual(normalize_header_key("Final Score"), "results")
|
|
|
|
def test_read_csv(self):
|
|
# Assuming that the CSV file has a valid header
|
|
with self.subTest("Read CSV data"):
|
|
data = read_and_normalize_csv_or_xlsx(self.test_csv_path_2009)
|
|
self.assertIsInstance(data, list)
|
|
self.assertTrue(all(isinstance(row, dict) for row in data))
|
|
with self.subTest("Normalized keys"):
|
|
normalized_data = read_and_normalize_csv_or_xlsx(self.test_csv_path_2009)
|
|
self.assertTrue(all("visitor" in row.keys() and "results" in row.keys() for row in normalized_data))
|
|
|
|
def test_parse_score_visitor_first(self):
|
|
with self.subTest('visitor win'):
|
|
score_str = "5-3"
|
|
expected_result = {
|
|
"has_result":True,
|
|
"home_outcome":"loss",
|
|
"visitor_outcome":"win",
|
|
"home_runs_for": 3, "visitor_runs_for": 5,
|
|
"home_runs_against": 5, "visitor_runs_against": 3
|
|
}
|
|
result = parse_score(score_str)
|
|
self.assertDictEqual(result, expected_result)
|
|
with self.subTest('visitor loss'):
|
|
score_str = "3-5"
|
|
expected_result = {
|
|
"has_result":True,
|
|
"home_outcome":"win",
|
|
"visitor_outcome":"loss",
|
|
"home_runs_for": 5, "visitor_runs_for": 3,
|
|
"home_runs_against": 3, "visitor_runs_against": 5
|
|
}
|
|
result = parse_score(score_str)
|
|
self.assertDictEqual(result, expected_result)
|
|
|
|
def test_parse_score_visitor_first_with_pre_post(self):
|
|
score_str = "5-3xxxx"
|
|
expected_result = {
|
|
"has_result":True,
|
|
"home_outcome":"loss",
|
|
"visitor_outcome":"win",
|
|
"home_runs_for": 3, "visitor_runs_for": 5,
|
|
"home_runs_against": 5, "visitor_runs_against": 3,
|
|
"post":"xxxx"
|
|
}
|
|
result = parse_score(score_str)
|
|
self.assertEqual(result, expected_result)
|
|
# score_str = "xxxx5-3xx"
|
|
# expected_result = {"home_runs_for": 3, "visitor_runs_for": 5, "home_runs_against": 5, "visitor_runs_against": 3, "pre":"xxxx", "post":"xx"}
|
|
# result = parse_score(score_str)
|
|
# self.assertDictEqual(result, expected_result)
|
|
|
|
|
|
def test_parse_score_home_first(self):
|
|
score_str = "2-4"
|
|
with self.subTest("home loss"):
|
|
expected_result = {
|
|
"has_result":True,
|
|
"home_outcome":"loss",
|
|
"visitor_outcome":"win",
|
|
"home_runs_for": 2, "visitor_runs_for": 4,
|
|
"home_runs_against": 4, "visitor_runs_against": 2
|
|
}
|
|
score_str = "2-4"
|
|
result = parse_score(score_str, reverse_order=True)
|
|
self.assertDictEqual(result, expected_result)
|
|
with self.subTest("home win"):
|
|
expected_result = {
|
|
"has_result":True,
|
|
"home_outcome":"win",
|
|
"visitor_outcome":"loss",
|
|
"home_runs_for": 4, "visitor_runs_for": 2,
|
|
"home_runs_against": 2, "visitor_runs_against": 4
|
|
}
|
|
score_str = "4-2"
|
|
result = parse_score(score_str, reverse_order=True)
|
|
self.assertDictEqual(result, expected_result)
|
|
|
|
def test_parse_score_invalid_format(self):
|
|
score_str = "invalid_format"
|
|
expected_result = {'has_result': False, "post":"invalid_format"}
|
|
result = parse_score(score_str)
|
|
self.assertDictEqual(result, expected_result)
|
|
|
|
def test_is_visitor_home_order_reversed_true(self):
|
|
header = ["date", "time", "field", "visitor", "home", "results", "results"]
|
|
result = is_visitor_home_order_reversed(header)
|
|
self.assertFalse(result)
|
|
|
|
def test_is_visitor_home_order_reversed_false(self):
|
|
header = ["date", "time", "field", "home", "visitor", "results", "results"]
|
|
result = is_visitor_home_order_reversed(header)
|
|
self.assertTrue(result)
|
|
|
|
def test_process_data(self):
|
|
# Assuming that the CSV file has a valid header and read_csv is good
|
|
data = read_and_normalize_csv_or_xlsx(self.test_csv_path_2009)
|
|
processed_data = import_gamebygame(data)
|
|
aggregate_team_data = aggregate_teams(processed_data)
|
|
expected_result = [
|
|
{"team": "Marlins", "gp": 28, "win": 23, "loss": 5, "tie": 0, "pts": 46, "runs_for": 249, "runs_against": 117},
|
|
{"team": "Mets", "gp": 28, "win": 20, "loss": 8, "tie": 0, "pts": 40, "runs_for": 265, "runs_against": 150},
|
|
{"team": "Browns", "gp": 28, "win": 17, "loss": 11, "tie": 0, "pts": 34, "runs_for": 221, "runs_against": 201},
|
|
{"team": "Yankees", "gp": 28, "win": 15, "loss": 12, "tie": 1, "pts": 31, "runs_for": 189, "runs_against": 163},
|
|
{"team": "Rangers", "gp": 28, "win": 15, "loss": 13, "tie": 0, "pts": 30, "runs_for": 203, "runs_against": 188},
|
|
{"team": "Hounds", "gp": 28, "win": 14, "loss": 14, "tie": 0, "pts": 28, "runs_for": 181, "runs_against": 161},
|
|
{"team": "Electrons", "gp": 28, "win": 13, "loss": 14, "tie": 1, "pts": 27, "runs_for": 168, "runs_against": 185},
|
|
{"team": "Vikings", "gp": 28, "win": 12, "loss": 16, "tie": 0, "pts": 24, "runs_for": 201, "runs_against": 229},
|
|
{"team": "Athletics", "gp": 28, "win": 8, "loss": 18, "tie": 2, "pts": 18, "runs_for": 157, "runs_against": 258},
|
|
{"team": "Red Sox", "gp": 28, "win": 8, "loss": 20, "tie": 0, "pts": 16, "runs_for": 156, "runs_against": 244},
|
|
{"team": "Aviators", "gp": 28, "win": 7, "loss": 21, "tie": 0, "pts": 14, "runs_for": 168, "runs_against": 262}
|
|
]
|
|
for team, expected_dict in [(row['team'], row) for row in expected_result]:
|
|
with self.subTest(f'Contains team "{team}"'):
|
|
aggregate_team_data_dict = [item for item in aggregate_team_data if item.get('team') == team]
|
|
len(aggregate_team_data_dict) == 1
|
|
aggregate_team_data_dict = aggregate_team_data_dict[0]
|
|
with self.subTest(f'Results of "{team}"'):
|
|
self.assertDictContainsSubset(aggregate_team_data_dict, expected_dict)
|
|
|
|
class TestNormalization(unittest.TestCase):
|
|
|
|
def test_normalize_key(self):
|
|
header_key_normalization = {
|
|
"date": {"potential_keys": ["Date", "EventDate"]},
|
|
"time": {"potential_keys": ["Time", "EventTime"]},
|
|
"visitor": {"potential_keys": ["Away"]},
|
|
"field":
|
|
{
|
|
"potential_keys": ["Field", "Location", "Venue"],
|
|
"values": [{"original": ["Winnemac"], "normalized": "Winnemac Park"}],
|
|
}
|
|
|
|
}
|
|
# Test cases for normalize_key function
|
|
self.assertEqual(normalize_header_key("Date", header_key_normalization), "date")
|
|
self.assertEqual(normalize_header_key("Time", header_key_normalization), "time")
|
|
self.assertEqual(normalize_header_key("Venue", header_key_normalization), "field")
|
|
self.assertEqual(normalize_header_key("Away", header_key_normalization), "visitor")
|
|
|
|
def test_load_config_file(self):
|
|
expected = {
|
|
"win": {"potential_keys": ["w", "wins"]},
|
|
"loss": {"potential_keys": ["l", "losses"]},
|
|
"tie": {"potential_keys": ["t", "ties"]},
|
|
"points": {"potential_keys": ["pts.", "pts", "pt"]},
|
|
"runs_for": {"potential_keys": ["rf", "rs"]},
|
|
"runs_against": {"potential_keys": ["ra"]},
|
|
"division": {"potential_keys": ["div"]},
|
|
"date": {"potential_keys": ["Date", "EventDate"]},
|
|
"time": {"potential_keys": ["Time", "EventTime"]},
|
|
"visitor": {"potential_keys": ["Away"]},
|
|
"field": {
|
|
"potential_keys": ["Field", "Location", "Venue"],
|
|
"values": [{"original": ["Winnemac"], "normalized": "Winnemac Park"}],
|
|
},
|
|
"results": {"potential_keys": ["Final Score", "Score", "Result", "Outcome"]},
|
|
"team": {
|
|
"values": [
|
|
{
|
|
"original": ["Hounds", "Chicago Hounds", "Winnemac Hounds", "Hound"],
|
|
"normalized": "Hounds",
|
|
},
|
|
{"original": ["Chicago Red Sox"], "normalized": "Red Sox"},
|
|
]
|
|
},
|
|
}
|
|
|
|
|
|
config_path = "normalization.toml"
|
|
config = load_config(config_path)
|
|
|
|
self.assertEqual(config, expected)
|
|
|
|
|
|
def test_normalize_value(self):
|
|
# Test cases for normalize_value function
|
|
team_normalization = {
|
|
"team": {
|
|
"values": [
|
|
{
|
|
"original": ["Hounds", "Chicago Hounds", "Winnemac Hounds", "Hound"],
|
|
"normalized": "Hounds",
|
|
},
|
|
{"original": ["Chicago Red Sox"], "normalized": "Red Sox"},
|
|
]
|
|
}
|
|
}
|
|
|
|
# Test case with normalization
|
|
self.assertEqual(normalize_value("Chicago Hounds", 'team', team_normalization), "Hounds")
|
|
|
|
# Test case without title case normalization
|
|
# self.assertEqual(normalize_value("red sox", team_normalization, 'team'), "Red Sox")
|
|
|
|
# Add more test cases for other values
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|