Update tests to account for API changes

Author: NeonDaniel

test/test_skill.py

@@ -38,6 +38,7 @@
 from neon_minerva.tests.skill_unit_test_base import SkillTestCase
 
 from skill_date_time import TimeSkill
+from skill_date_time.api_data_models import TimeInLocationRequest
 
 environ['TEST_SKILL_ENTRYPOINT'] = 'skill-date_time.neongeckocom'
 
@@ -82,35 +83,40 @@ def clear():
 
         self.skill.gui = real_gui
 
-    def test_get_display_date(self):
+    @patch('skill_date_time.dig_for_message')
+    @patch.object(TimeSkill, 'get_local_datetime')
+    def test_get_display_date(self, get_time, dig_for_message):
         from neon_utils.user_utils import get_default_user_config
         config = get_default_user_config()
         config['user']['username'] = 'test_user'
         config['units']['date'] = "MDY"
         test_message = Message("test", {}, {"username": "test_user",
                                             "user_profiles": [config]})
+        dig_for_message.return_value = test_message
 
         test_date = dt.datetime(month=1, day=2, year=2000)
+        get_time.return_value = test_date
 
-        date_str = self.skill.get_display_date(test_date, message=test_message)
+        date_str = self.skill.get_display_date()
         self.assertEqual(date_str, "1/2/2000")
 
         config['units']['date'] = "DMY"
         test_message = Message("test", {}, {"username": "test_user",
                                             "user_profiles": [config]})
-        date_str = self.skill.get_display_date(test_date, message=test_message)
+        dig_for_message.return_value = test_message
+
+        date_str = self.skill.get_display_date()
         self.assertEqual(date_str, "2/1/2000")
 
         config['units']['date'] = "YMD"
         test_message = Message("test", {}, {"username": "test_user",
                                             "user_profiles": [config]})
-        date_str = self.skill.get_display_date(test_date, message=test_message)
+        dig_for_message.return_value = test_message
+        date_str = self.skill.get_display_date()
         self.assertEqual(date_str, "2000/1/2")
 
-        now_date_str = self.skill.get_display_date()
-        self.assertNotEqual(date_str, now_date_str)
-
-    def test_get_display_current_time(self):
+    @patch('skill_date_time.dig_for_message')
+    def test_get_display_current_time(self, dig_for_message):
         from neon_utils.user_utils import get_default_user_config
         config = get_default_user_config()
         config['user']['username'] = 'test_user'
@@ -121,7 +127,7 @@ def test_get_display_current_time(self):
         self.assertEqual(len(current_time.split(':')), 2)
 
         # Specify location
-        current_time_honolulu = self.skill.get_display_current_time("honolulu")
+        current_time_honolulu = self.skill.get_display_current_time(TimeInLocationRequest(location="honolulu"))
         self.assertIsInstance(current_time_honolulu, str)
         self.assertEqual(len(current_time_honolulu.split(':')), 2)
         self.assertIn('m', current_time_honolulu.lower())
@@ -130,54 +136,65 @@ def test_get_display_current_time(self):
         config['units']['time'] = 24
         test_message = Message("test", {}, {"username": "test_user",
                                             "user_profiles": [config]})
+        dig_for_message.return_value = test_message
 
         # Default location, specify time 24h
-        dt_utc = dt.datetime.now(dt.timezone.utc).replace(hour=23, minute=30)
-        utc_time = self.skill.get_display_current_time(dt_utc=dt_utc,
-                                                       message=test_message)
-        self.assertEqual(utc_time, "23:30")
+        #dt_utc = dt.datetime.now(dt.timezone.utc).replace(hour=23, minute=30)
+        utc_time = self.skill.get_display_current_time()
+        self.assertEqual(len(utc_time.split()), 1)  # "23:30"
 
-        # Specify location, 24h
-        az_time = self.skill.get_display_current_time("phoenix", dt_utc,
-                                                      message=test_message)
-        self.assertEqual(az_time, "16:30")
+        ## Specify location, 24h
+        #az_time = self.skill.get_display_current_time("phoenix", dt_utc,
+        #                                              message=test_message)
+        #self.assertEqual(az_time, "16:30")
 
         self.skill.settings['use_ampm'] = True
         config['units']['time'] = 12
 
         # Default location with AM/PM
         test_message = Message("test", {}, {"username": "test_user",
                                             "user_profiles": [config]})
-        utc_time = self.skill.get_display_current_time(dt_utc=dt_utc,
-                                                       message=test_message)
-        self.assertEqual(utc_time, "11:30 PM")
+        dig_for_message.return_value = test_message
 
-        # Specify location with AM/PM
-        az_time = self.skill.get_display_current_time("phoenix", dt_utc,
-                                                      message=test_message)
-        self.assertEqual(az_time, "4:30 PM")
+        utc_time = self.skill.get_display_current_time()
+        self.assertEqual(len(utc_time.split()), 2)  # "11:30 PM"
+
+        # # Specify location with AM/PM
+        # az_time = self.skill.get_display_current_time("phoenix", dt_utc,
+        #                                               message=test_message)
+        # self.assertEqual(az_time, "4:30 PM")
 
         self.skill.settings['use_ampm'] = False
         # Default location, no AM/PM
-        utc_time = self.skill.get_display_current_time(dt_utc=dt_utc,
-                                                       message=test_message)
-        self.assertEqual(utc_time, "11:30")
+        utc_time = self.skill.get_display_current_time()
+        self.assertEqual(len(utc_time.split()), 1)  # "23:30"
         # Specify location, always shows AM/PM
-        az_time = self.skill.get_display_current_time("phoenix", dt_utc,
-                                                      message=test_message)
-        self.assertEqual(az_time, "4:30 PM")
+        az_time = self.skill.get_display_current_time(TimeInLocationRequest(location="phoenix"))
+        self.assertEqual(len(az_time.split()), 2)  # "4:30 PM"
 
-    def test_get_weekday(self):
+    @patch.object(TimeSkill, 'get_local_datetime')
+    def test_get_weekday(self, get_local_datetime):
+        # Simple case
+        get_local_datetime.return_value = dt.datetime.now(dt.timezone.utc)
         self.assertIsInstance(self.skill.get_weekday(), str)
+        
+        # Relative day change
         today = dt.datetime.now(dt.timezone.utc)
+        get_local_datetime.return_value = today
+        today_day = self.skill.get_weekday()
         tomorrow = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=1)
-        self.assertNotEqual(self.skill.get_weekday(today),
-                            self.skill.get_weekday(tomorrow))
-        self.assertEqual(self.skill.get_weekday(location="Seattle"),
-                         self.skill.get_weekday(location="Portland"))
+        get_local_datetime.return_value = tomorrow
+        tomorrow_day = self.skill.get_weekday()
+        self.assertNotEqual(today_day, tomorrow_day)
+
+        # With Location
+        self.assertEqual(self.skill.get_weekday(TimeInLocationRequest(location="Seattle")),
+                         self.skill.get_weekday(TimeInLocationRequest(location="Portland")))
 
+        # Specific known case
         known_day = dt.datetime(day=1, month=1, year=2000)
-        self.assertEqual(self.skill.get_weekday(known_day), "Saturday")
+        get_local_datetime.return_value = known_day
+        self.assertEqual(self.skill.get_weekday(), "Saturday")
 
     @patch('skill_date_time.dig_for_message')
     @patch.object(TimeSkill, 'get_local_datetime')
@@ -212,12 +229,19 @@ def test_get_month_date(self, get_local_datetime, dig_for_message):
 
         # TODO: Validate with non-mocked get_local_datetime and location input
 
-    def test_get_year(self):
+    @patch.object(TimeSkill, 'get_local_datetime')
+    def test_get_year(self, get_local_datetime):
+        # Test simple case
+        get_local_datetime.return_value = dt.datetime.now(dt.timezone.utc)
         self.assertIsInstance(self.skill.get_year(), str)
+
+        # Test known case
         date = datetime.datetime(month=1, day=1, year=2000)
-        self.assertEqual(self.skill.get_year(date), "2000")
-        self.assertEqual(self.skill.get_year(date, "Seattle"), "2000")
-        self.assertIsInstance(self.skill.get_year(location="Seattle"), str)
+        get_local_datetime.return_value = date
+        self.assertEqual(self.skill.get_year(), "2000")
+        # Test with location input
+        self.assertEqual(self.skill.get_year(TimeInLocationRequest(location="Seattle")),
+                         "2000")
 
     def test_get_next_leap_year(self):
         for year in (2000, 2001, 2002, 2003):