Merge branch 'master' into found-not-found-caches

Author: jarhill0

test/__init__.py

@@ -23,16 +23,16 @@
     config.before_record(callback=sanitize_cookies)
 
 Betamax.register_serializer(PrettyJSONSerializer)
-session = Session()
-recorder = Betamax(session, default_cassette_options={'serialize_with': 'prettyjson'})
 
 
 class NetworkedTest(unittest.TestCase):
     """Class to represent tests that perform network requests"""
 
     @classmethod
     def setUpClass(cls):
-        cls.gc = Geocaching(session=session)
+        cls.session = Session()
+        cls.recorder = Betamax(cls.session, default_cassette_options={'serialize_with': 'prettyjson'})
+        cls.gc = Geocaching(session=cls.session)
         try:
             cls.gc.login(username, password)
         except Error:
@@ -43,4 +43,4 @@ def setUpClass(cls):
             # because if we are recording new cassettes this means we cannot get
             # properly logged in.
             cls.gc._logged_in = True  # we're gonna trick it
-            cls.gc._session = session  # it got redefined; fix it
+            cls.gc._session = cls.session  # it got redefined; fix it

test/test_cache.py

@@ -9,7 +9,7 @@
 from pycaching.geocaching import Geocaching
 from pycaching.log import Log, Type as LogType
 from pycaching.util import parse_date
-from . import recorder, NetworkedTest
+from . import NetworkedTest
 
 
 class TestProperties(unittest.TestCase):
@@ -169,49 +169,49 @@ class TestMethods(NetworkedTest):
     def setUpClass(cls):
         super().setUpClass()
         cls.c = Cache(cls.gc, "GC1PAR2")
-        with recorder.use_cassette('cache_setup'):
+        with cls.recorder.use_cassette('cache_setup'):
             cls.c.load()
 
     def test_load(self):
         with self.subTest("normal (with explicit call of load())"):
-            with recorder.use_cassette('cache_explicit_load'):
+            with self.recorder.use_cassette('cache_explicit_load'):
                 cache = Cache(self.gc, "GC4808G")
                 cache.load()
             self.assertEqual("Nekonecne ticho", cache.name)
 
         with self.subTest("normal"):
-            with recorder.use_cassette('cache_normal_normal'):
+            with self.recorder.use_cassette('cache_normal_normal'):
                 cache = Cache(self.gc, "GC4808G")
                 self.assertEqual("Nekonecne ticho", cache.name)
 
         with self.subTest("non-ascii chars"):
-            with recorder.use_cassette('cache_non-ascii'):
+            with self.recorder.use_cassette('cache_non-ascii'):
                 cache = Cache(self.gc, "GC5VJ0P")
                 self.assertEqual("u parezové chaloupky", cache.hint)
 
         with self.subTest("PM only"):
-            with recorder.use_cassette('cache_PMO'):
+            with self.recorder.use_cassette('cache_PMO'):
                 with self.assertRaises(PMOnlyException):
                     cache = Cache(self.gc, "GC3AHDM")
                     cache.load()
 
         with self.subTest("fail"):
-            with recorder.use_cassette('cache_normal_fail'):
+            with self.recorder.use_cassette('cache_normal_fail'):
                 with self.assertRaises(LoadError):
                     cache = Cache(self.gc, "GC123456")
                     cache.load()
 
     def test_load_quick(self):
         with self.subTest("normal"):
-            with recorder.use_cassette('cache_quick_normal'):
+            with self.recorder.use_cassette('cache_quick_normal'):
                 cache = Cache(self.gc, "GC4808G")
                 cache.load_quick()
             self.assertEqual(4, cache.terrain)
             self.assertEqual(Size.regular, cache.size)
             self.assertEqual(cache.guid, "15ad3a3d-92c1-4f7c-b273-60937bcc2072")
 
         with self.subTest("fail"):
-            with recorder.use_cassette('cache_quickload_fail'):
+            with self.recorder.use_cassette('cache_quickload_fail'):
                 with self.assertRaises(LoadError):
                     cache = Cache(self.gc, "GC123456")
                     cache.load_quick()
@@ -221,7 +221,7 @@ def test_load_quick(self):
     def test_load_by_guid(self, mock_load_quick, mock_load):
         with self.subTest("normal"):
             cache = Cache(self.gc, "GC2WXPN", guid="5f45114d-1d79-4fdb-93ae-8f49f1d27188")
-            with recorder.use_cassette('cache_guidload_normal'):
+            with self.recorder.use_cassette('cache_guidload_normal'):
                 cache.load_by_guid()
             self.assertEqual(cache.name, "Der Schatz vom Luftschloss")
             self.assertEqual(cache.location, Point("N 49° 57.895' E 008° 12.988'"))
@@ -247,25 +247,25 @@ def test_load_by_guid(self, mock_load_quick, mock_load):
 
         with self.subTest("PM-only"):
             cache = Cache(self.gc, "GC6MKEF", guid="53d34c4d-12b5-4771-86d3-89318f71efb1")
-            with recorder.use_cassette('cache_guidload_PMO'):
+            with self.recorder.use_cassette('cache_guidload_PMO'):
                 with self.assertRaises(PMOnlyException):
                     cache.load_by_guid()
 
         with self.subTest("calls load_quick if no guid"):
             cache = Cache(self.gc, "GC2WXPN")
-            with recorder.use_cassette('cache_guidload_fallback'):
+            with self.recorder.use_cassette('cache_guidload_fallback'):
                 with self.assertRaises(Exception):
                     cache.load_by_guid()  # Raises error since we mocked load_quick()
             self.assertTrue(mock_load_quick.called)
 
     def test_load_trackables(self):
         cache = Cache(self.gc, "GC26737")  # TB graveyard - will surelly have some trackables
-        with recorder.use_cassette('cache_trackables'):
+        with self.recorder.use_cassette('cache_trackables'):
             trackable_list = list(cache.load_trackables(limit=10))
         self.assertTrue(isinstance(trackable_list, list))
 
     def test_load_logbook(self):
-        with recorder.use_cassette('cache_logbook'):
+        with self.recorder.use_cassette('cache_logbook'):
             # limit over 100 tests pagination
             log_authors = list(map(lambda log: log.author, self.c.load_logbook(limit=200)))
         for expected_author in ["Dudny-1995", "Sopdet Reviewer", "donovanstangiano83"]:
@@ -274,7 +274,7 @@ def test_load_logbook(self):
     def test_load_log_page(self):
         expected_types = {t.value for t in (LogType.found_it, LogType.didnt_find_it, LogType.note)}
 
-        with recorder.use_cassette('cache_logpage'):
+        with self.recorder.use_cassette('cache_logpage'):
             # make request
             valid_types, hidden_inputs = self.c._load_log_page()
 

test/test_geo.py

@@ -12,7 +12,7 @@
 from pycaching.errors import GeocodeError, BadBlockError
 from pycaching.geo import Point, Polygon, Rectangle, Tile, UTFGridPoint, Block
 from pycaching.geo import to_decimal
-from . import recorder, NetworkedTest
+from . import NetworkedTest
 
 _sample_caches_file = path.join(path.dirname(__file__), "sample_caches.csv")
 _sample_utfgrid_file = path.join(path.dirname(__file__), "sample_utfgrid.json")
@@ -69,18 +69,18 @@ def test_from_location(self):
         ref_point = Point(50.08746, 14.42125)
 
         with self.subTest("existing location"):
-            with recorder.use_cassette('geo_location_existing'):
+            with self.recorder.use_cassette('geo_location_existing'):
                 self.assertLess(great_circle(Point.from_location(self.gc, "Prague"), ref_point).miles, 10)
                 self.assertLess(great_circle(Point.from_location(self.gc, "Praha"), ref_point).miles, 10)
                 self.assertLess(great_circle(Point.from_location(self.gc, "praha"), ref_point).miles, 10)
 
         with self.subTest("non-existing location"):
-            with recorder.use_cassette('geo_location_nonexisting'):
+            with self.recorder.use_cassette('geo_location_nonexisting'):
                 with self.assertRaises(GeocodeError):
                     Point.from_location(self.gc, "qwertzuiop")
 
         with self.subTest("empty request"):
-            with recorder.use_cassette('geo_location_empty'):
+            with self.recorder.use_cassette('geo_location_empty'):
                 with self.assertRaises(GeocodeError):
                     Point.from_location(self.gc, "")
 
@@ -187,7 +187,7 @@ def setUp(self):
 
     def test_download_utfgrid(self):
         """Test if downloading a UTFGrid passes without errors"""
-        with recorder.use_cassette('geo_point_utfgrid'):
+        with self.recorder.use_cassette('geo_point_utfgrid'):
             with self.subTest("not getting .png tile first"):
                 self.tile._download_utfgrid()
 

test/test_geocaching.py

@@ -13,12 +13,12 @@
 import pycaching
 from pycaching import Cache, Geocaching, Point, Rectangle
 from pycaching.errors import NotLoggedInException, LoginFailedException, PMOnlyException
-from . import username as _username, password as _password, recorder, session, NetworkedTest
+from . import username as _username, password as _password, NetworkedTest
 
 
 class TestMethods(NetworkedTest):
     def test_my_finds(self):
-        with recorder.use_cassette('geocaching_my_finds'):
+        with self.recorder.use_cassette('geocaching_my_finds'):
             finds = list(self.gc.my_finds(20))
             self.assertEqual(20, len(finds))
             for cache in finds:
@@ -37,12 +37,12 @@ def test_search(self):
         with self.subTest("normal"):
             tolerance = 2
             expected = {"GC5VJ0P", "GC41FJC", "GC17E8Y", "GC14AV5", "GC50AQ6", "GC167Y7"}
-            with recorder.use_cassette('geocaching_search'):
+            with self.recorder.use_cassette('geocaching_search'):
                 found = {cache.wp for cache in self.gc.search(Point(49.733867, 13.397091), 20)}
             self.assertGreater(len(expected & found), len(expected) - tolerance)
 
         with self.subTest("pagging"):
-            with recorder.use_cassette('geocaching_search_pagination'):
+            with self.recorder.use_cassette('geocaching_search_pagination'):
                 caches = list(self.gc.search(Point(49.733867, 13.397091), 100))
             self.assertNotEqual(caches[0], caches[50])
 
@@ -55,7 +55,7 @@ def test_search_quick(self):
         rect = Rectangle(Point(49.73, 13.38), Point(49.74, 13.40))
 
         with self.subTest("normal"):
-            with recorder.use_cassette('geocaching_quick_normal'):
+            with self.recorder.use_cassette('geocaching_quick_normal'):
                 # Once this feature is fixed, the corresponding cassette will have to be deleted
                 # and re-recorded.
                 res = [c.wp for c in self.gc.search_quick(rect)]
@@ -66,13 +66,13 @@ def test_search_quick(self):
             self.assertGreater(len(res), 90)
 
         with self.subTest("strict handling of cache coordinates"):
-            with recorder.use_cassette('geocaching_quick_strictness'):
+            with self.recorder.use_cassette('geocaching_quick_strictness'):
                 res = list(self.gc.search_quick(rect, strict=True))
             self.assertLess(len(res), expected_cache_num + tolerance)
             self.assertGreater(len(res), expected_cache_num - tolerance)
 
         with self.subTest("larger zoom - more precise"):
-            with recorder.use_cassette('geocaching_quick_zoom'):
+            with self.recorder.use_cassette('geocaching_quick_zoom'):
                 res1 = list(self.gc.search_quick(rect, strict=True, zoom=15))
                 res2 = list(self.gc.search_quick(rect, strict=True, zoom=14))
             for res in res1, res2:
@@ -85,7 +85,7 @@ def test_search_quick(self):
     def test_search_quick_match_load(self):
         """Test if quick search results matches exact cache locations."""
         rect = Rectangle(Point(49.73, 13.38), Point(49.74, 13.39))
-        with recorder.use_cassette('geocaching_matchload'):
+        with self.recorder.use_cassette('geocaching_matchload'):
             # at commit time, this test is an allowed failure. Once this feature is fixed, the
             # corresponding cassette will have to be deleted and re-recorded.
             caches = list(self.gc.search_quick(rect, strict=True, zoom=15))
@@ -100,7 +100,7 @@ def test_search_quick_match_load(self):
 class TestLoginOperations(NetworkedTest):
     def setUp(self):
         super().setUp()
-        self.gc = Geocaching(session=session)
+        self.gc = Geocaching(session=self.session)
 
     def test_request(self):
         with self.subTest("login needed"):
@@ -109,24 +109,24 @@ def test_request(self):
 
     def test_login(self):
         with self.subTest("bad credentials"):
-            with recorder.use_cassette('geocaching_badcreds'):
-                session.cookies.clear()
+            with self.recorder.use_cassette('geocaching_badcreds'):
+                self.session.cookies.clear()
                 with self.assertRaises(LoginFailedException):
                     self.gc.login("0", "0")
 
         with self.subTest("good credentials twice"):
             self.gc.logout()
-            session.cookies.clear()
-            self.gc._session = session  # gotta reattach so we can keep listening
-            with recorder.use_cassette('geocaching_2login'):
+            self.session.cookies.clear()
+            self.gc._session = self.session  # gotta reattach so we can keep listening
+            with self.recorder.use_cassette('geocaching_2login'):
                 self.gc.login(_username, _password)
                 self.gc.login(_username, _password)
 
         with self.subTest("bad credentials automatic logout"):
-            with recorder.use_cassette('geocaching_badcreds_logout'):
+            with self.recorder.use_cassette('geocaching_badcreds_logout'):
                 self.gc.logout()
-                session.cookies.clear()
-                self.gc._session = session  # gotta reattach so we can keep listening
+                self.session.cookies.clear()
+                self.gc._session = self.session  # gotta reattach so we can keep listening
                 with self.assertRaises(LoginFailedException):
                     self.gc.login("0", "0")
 
@@ -161,16 +161,16 @@ def test_login(self):
                     self.gc.login()
 
     def test_get_logged_user(self):
-        with recorder.use_cassette('geocaching_loggeduser'):
+        with self.recorder.use_cassette('geocaching_loggeduser'):
             self.gc.login(_username, _password)
             self.assertEqual(self.gc.get_logged_user(), _username)
 
     def test_logout(self):
-        with recorder.use_cassette('geocaching_logout'):
+        with self.recorder.use_cassette('geocaching_logout'):
             self.gc.login(_username, _password)
             self.gc.logout()
-            session.cookies.clear()
-            self.gc._session = session  # gotta reattach so we can keep listening
+            self.session.cookies.clear()
+            self.gc._session = self.session  # gotta reattach so we can keep listening
             self.assertIsNone(self.gc.get_logged_user())
 
     def test_load_credentials(self):
@@ -279,30 +279,30 @@ def test_login(self):
         real_init = Geocaching.__init__
 
         def fake_init(self_, unused_argument=None):
-            real_init(self_, session=session)
+            real_init(self_, session=self.session)
 
         # patching with the fake init method above to insert our session into the Geocaching object for testing
         with patch.object(Geocaching, '__init__', new=fake_init):
-            with recorder.use_cassette('geocaching_shortcut_login'):
+            with self.recorder.use_cassette('geocaching_shortcut_login'):
                 pycaching.login(_username, _password)
 
     def test_geocode(self):
         ref_point = Point(50.08746, 14.42125)
-        with recorder.use_cassette('geocaching_shortcut_geocode'):
+        with self.recorder.use_cassette('geocaching_shortcut_geocode'):
             self.assertLess(great_circle(self.gc.geocode("Prague"), ref_point).miles, 10)
 
     def test_get_cache(self):
-        with recorder.use_cassette('geocaching_shortcut_getcache'):
+        with self.recorder.use_cassette('geocaching_shortcut_getcache'):
             c = self.gc.get_cache("GC4808G")
             self.assertEqual("Nekonecne ticho", c.name)
 
     def test_get_cache__by_guid(self):
-        with recorder.use_cassette('geocaching_shortcut_getcache__by_guid'):
+        with self.recorder.use_cassette('geocaching_shortcut_getcache__by_guid'):
             cache = self.gc.get_cache(guid='15ad3a3d-92c1-4f7c-b273-60937bcc2072')
             self.assertEqual("Nekonecne ticho", cache.name)
 
     def test_get_trackable(self):
-        with recorder.use_cassette('geocaching_shortcut_gettrackable'):
+        with self.recorder.use_cassette('geocaching_shortcut_gettrackable'):
             t = self.gc.get_trackable("TB1KEZ9")
             self.assertEqual("Lilagul #2: SwedenHawk Geocoin", t.name)
 

test/test_trackable.py

@@ -7,7 +7,7 @@
 from pycaching import Geocaching, Trackable
 from pycaching.errors import ValueError as PycachingValueError, LoadError
 from pycaching.log import Log, Type as LogType
-from . import recorder, NetworkedTest
+from . import NetworkedTest
 
 
 class TestProperties(unittest.TestCase):
@@ -53,19 +53,19 @@ class TestMethods(NetworkedTest):
     def setUpClass(cls):
         super().setUpClass()
         cls.t = Trackable(cls.gc, "TB1KEZ9")
-        with recorder.use_cassette('trackable_setup'):
+        with cls.recorder.use_cassette('trackable_setup'):
             cls.t.load()
 
     def test_load(self):
         with self.subTest("tid"):
             trackable = Trackable(self.gc, "TB1KEZ9")
-            with recorder.use_cassette('trackable_load_tid'):
+            with self.recorder.use_cassette('trackable_load_tid'):
                 self.assertEqual("Lilagul #2: SwedenHawk Geocoin", trackable.name)
 
         with self.subTest("trackable url"):
             url = "http://www.geocaching.com/track/details.aspx?guid=cff00ac4-f562-486e-b303-32b2d01ed386"
             trackable = Trackable(self.gc, None, url=url)
-            with recorder.use_cassette('trackable_load_url'):
+            with self.recorder.use_cassette('trackable_load_url'):
                 self.assertEqual("Lilagul #2: SwedenHawk Geocoin", trackable.name)
 
         with self.subTest("fail lazyload"):
@@ -79,7 +79,7 @@ def test_load_log_page(self):
         expected_date_format = "M/d/yyyy"  # if test is re-recorded, update for your testing account
 
         # make request
-        with recorder.use_cassette('trackable_load_page'):
+        with self.recorder.use_cassette('trackable_load_page'):
             valid_types, hidden_inputs, user_date_format = self.t._load_log_page()
 
         self.assertSequenceEqual(expected_types, valid_types)
@@ -126,7 +126,7 @@ def test_post_log(self, mock_request, mock_load_log_page):
             mock_request.assert_called_with(self.t._log_page_url, method="POST", data=expected_post_data)
 
     def test_get_KML(self):
-        with recorder.use_cassette('trackable_kml'):
+        with self.recorder.use_cassette('trackable_kml'):
             kml = self.t.get_KML()
         self.assertTrue("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" in kml)
         self.assertTrue("<kml xmlns=\"http://earth.google.com/kml/2.2\">" in kml)