def setUp(self):
self.gc = Geocaching()
self.t = Trackable("TB1234", self.gc, name="TrackMe")
self.c = Cache("GC12345",
self.gc,
name="Testing",
cache_type="Traditional Cache",
location=Point(),
state=True,
found=False,
size="micro",
difficulty=1.5,
terrain=5,
author="human",
hidden=date(2000, 1, 1),
attributes={
"onehour": True,
"kids": False,
"available": True
},
summary="text",
description="long text",
hint="rot13",
favorites=0,
pm_only=False,
trackables=self.t)
def test_from_location(self):
gc = Geocaching()
gc.login(_username, _password)
ref_point = Point(49.74774, 13.37752)
with self.subTest("existing location"):
self.assertLess(great_circle(Point.from_location(gc, "Pilsen"), ref_point).miles, 10)
self.assertLess(great_circle(Point.from_location(gc, "Plzeň"), ref_point).miles, 10)
self.assertLess(great_circle(Point.from_location(gc, "plzen"), ref_point).miles, 10)
with self.subTest("non-existing location"):
with self.assertRaises(GeocodeError):
Point.from_location(gc, "qwertzuiop")
with self.subTest("empty request"):
with self.assertRaises(GeocodeError):
Point.from_location(gc, "")
def mock_credentials_file(geocaching: Geocaching,
contents: Union[bytes, dict, list, str]):
"""Create a temporary credentials file with given contents and mock a Geocaching instance to use it."""
backup = geocaching._credentials_file
f = NamedTemporaryFile(delete=False)
try:
# bytes are written as-is, others are encoded to JSON
if type(contents) is bytes:
f.write(contents)
else:
f.write(json.dumps(contents).encode("utf-8"))
f.flush()
f.close()
geocaching._credentials_file = f.name
yield
finally:
os.remove(f.name)
geocaching._credentials_file = backup
def setUp(self):
self.gc = Geocaching()
self.t = Trackable("TB123AB",
self.gc,
name="Testing",
type="Travel Bug",
location=Point(),
owner="human",
description="long text",
goal="short text")
def setUp(self):
self.gc = Geocaching()
self.t = Trackable(self.gc,
"TB123AB",
name="Testing",
type="Travel Bug",
location="in the hands of human",
owner="human",
description="long text",
goal="short text")
self.t._log_page_url = "/track/details.aspx?id=6359246"
def test_from_location(self):
gc = Geocaching()
gc.login(_username, _password)
ref_point = Point(49.74774, 13.37752)
with self.subTest("existing location"):
self.assertLess(
great_circle(Point.from_location(gc, "Pilsen"),
ref_point).miles, 10)
self.assertLess(
great_circle(Point.from_location(gc, "Plzeň"),
ref_point).miles, 10)
self.assertLess(
great_circle(Point.from_location(gc, "plzen"),
ref_point).miles, 10)
with self.subTest("non-existing location"):
with self.assertRaises(GeocodeError):
Point.from_location(gc, "qwertzuiop")
with self.subTest("empty request"):
with self.assertRaises(GeocodeError):
Point.from_location(gc, "")
def setUpClass(cls):
cls.g = Geocaching()
cls.g.login(_username, _password)
def setUp(self):
self.g = Geocaching()
class TestLoginOperations(unittest.TestCase):
def setUp(self):
self.g = Geocaching()
def test_login(self):
with self.subTest("bad username"):
with self.assertRaises(LoginFailedException):
self.g.login("", "")
with self.subTest("good username"):
self.g.login(_username, _password)
with self.subTest("good username already logged"):
self.g.login(_username, _password)
with self.subTest("bad username automatic logout"):
with self.assertRaises(LoginFailedException):
self.g.login("", "")
def test_get_logged_user(self):
self.g.login(_username, _password)
self.assertEqual(self.g.get_logged_user(), _username)
def test_logout(self):
self.g.login(_username, _password)
self.g.logout()
self.assertIsNone(self.g.get_logged_user())
def tearDown(self):
self.g.logout()
def setUp(self):
self.g = Geocaching()
class TestLoginOperations(NetworkedTest):
def setUp(self):
super().setUp()
self.gc = Geocaching(session=self.session)
def test_request(self):
with self.subTest("login needed"):
with self.assertRaises(NotLoggedInException):
self.gc._request("/")
def test_login(self):
with self.subTest("bad credentials"):
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()
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 self.recorder.use_cassette('geocaching_badcreds_logout'):
self.gc.logout()
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")
with self.subTest(
"FileNotFoundError is reraised as LoginFailedException"):
with patch.object(Geocaching,
"_load_credentials",
side_effect=FileNotFoundError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("ValueError is reraised as LoginFailedException"):
with patch.object(Geocaching,
"_load_credentials",
side_effect=ValueError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("KeyError is reraised as LoginFailedException"):
with patch.object(Geocaching,
"_load_credentials",
side_effect=KeyError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("IOError is reraised as LoginFailedException"):
with patch.object(Geocaching,
"_load_credentials",
side_effect=IOError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest(
"CalledProcessError is reraised as LoginFailedException"):
with patch.object(Geocaching,
"_load_credentials",
side_effect=CalledProcessError(1, "error")):
with self.assertRaises(LoginFailedException):
self.gc.login()
def test_get_logged_user(self):
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 self.recorder.use_cassette('geocaching_logout'):
self.gc.login(_username, _password)
self.gc.logout()
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):
filename_backup = self.gc._credentials_file
credentials = {"username": _username, "password": _password}
empty_valid_json = {}
nonsense_str = b"ss{}ef"
password_cmd = "echo {}".format(_password)
invalid_cmd = "exit 1"
with self.subTest(
"Try to load nonexistent file from current directory"):
self.gc._credentials_file = "this_file_doesnt_exist.json"
with self.assertRaises(FileNotFoundError):
username, password = self.gc._load_credentials()
# each of the following subtests consists of:
# 1. creating tempfile with some contents and **closing it**
# 3. doing some tests (will reopen tempfile)
# 4. removing tempfile (whether the subtest passed or not)
with self.subTest(
"Try to load valid credentials from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as valid:
valid.write(json.dumps(credentials).encode())
self.gc._credentials_file = os.path.basename(valid.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(valid.name)
with self.subTest("Try to load empty file from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as empty:
empty.write(json.dumps(empty_valid_json).encode())
self.gc._credentials_file = os.path.basename(empty.name)
with self.assertRaises(KeyError):
self.gc._load_credentials()
finally:
os.remove(empty.name)
with self.subTest("Try to load nonsense file from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as nonsense:
nonsense.write(nonsense_str)
self.gc._credentials_file = os.path.basename(nonsense.name)
with self.assertRaises(ValueError):
self.gc._load_credentials()
finally:
os.remove(nonsense.name)
with self.subTest("Try to load valid credentials from home directory"):
try:
with NamedTemporaryFile(dir=os.path.expanduser("~"),
delete=False) as home_file:
home_file.write(json.dumps(credentials).encode())
self.gc._credentials_file = os.path.basename(home_file.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(home_file.name)
with self.subTest("Try to load credentials with password cmd"):
credentials_with_pass_cmd = {
"username": _username,
"password_cmd": password_cmd
}
try:
with NamedTemporaryFile(dir=".", delete=False) as valid:
valid.write(json.dumps(credentials_with_pass_cmd).encode())
self.gc._credentials_file = os.path.basename(valid.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(valid.name)
with self.subTest("Try to load credentials with invalid password cmd"):
credentials_with_pass_cmd = {
"username": _username,
"password_cmd": invalid_cmd
}
try:
with NamedTemporaryFile(dir=".", delete=False) as invalid:
invalid.write(
json.dumps(credentials_with_pass_cmd).encode())
self.gc._credentials_file = os.path.basename(invalid.name)
with self.assertRaises(CalledProcessError):
self.gc._load_credentials()
finally:
os.remove(invalid.name)
with self.subTest("Try to load credentials with ambiguous password"):
credentials_with_ambiguous_pass = {
"username": _username,
"password": _password,
"password_cmd": password_cmd
}
try:
with NamedTemporaryFile(dir=".", delete=False) as ambiguous:
ambiguous.write(
json.dumps(credentials_with_ambiguous_pass).encode())
self.gc._credentials_file = os.path.basename(ambiguous.name)
with self.assertRaises(KeyError):
self.gc._load_credentials()
finally:
os.remove(ambiguous.name)
self.gc._credentials_file = filename_backup
def setUp(self):
self.grid = UTFGrid(Geocaching(), 8800, 5574, 14)
def setUp(self):
super().setUp()
self.gc = Geocaching(session=self.session)
class TestLoginOperations(NetworkedTest):
def setUp(self):
super().setUp()
self.gc = Geocaching(session=self.session)
def test_request(self):
with self.subTest("login needed"):
with self.assertRaises(NotLoggedInException):
self.gc._request("/")
def test_login(self):
with self.subTest("bad credentials"):
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()
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 self.recorder.use_cassette('geocaching_badcreds_logout'):
self.gc.logout()
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")
with self.subTest("FileNotFoundError is reraised as LoginFailedException"):
with patch.object(Geocaching, "_load_credentials",
side_effect=FileNotFoundError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("ValueError is reraised as LoginFailedException"):
with patch.object(Geocaching, "_load_credentials",
side_effect=ValueError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("KeyError is reraised as LoginFailedException"):
with patch.object(Geocaching, "_load_credentials",
side_effect=KeyError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("IOError is reraised as LoginFailedException"):
with patch.object(Geocaching, "_load_credentials",
side_effect=IOError):
with self.assertRaises(LoginFailedException):
self.gc.login()
with self.subTest("CalledProcessError is reraised as LoginFailedException"):
with patch.object(Geocaching, "_load_credentials",
side_effect=CalledProcessError(1, "error")):
with self.assertRaises(LoginFailedException):
self.gc.login()
def test_get_logged_user(self):
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 self.recorder.use_cassette('geocaching_logout'):
self.gc.login(_username, _password)
self.gc.logout()
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):
filename_backup = self.gc._credentials_file
credentials = {"username": _username, "password": _password}
empty_valid_json = {}
nonsense_str = b"ss{}ef"
password_cmd = "echo {}".format(_password)
invalid_cmd = "exit 1"
with self.subTest("Try to load nonexistent file from current directory"):
self.gc._credentials_file = "this_file_doesnt_exist.json"
with self.assertRaises(FileNotFoundError):
username, password = self.gc._load_credentials()
# each of the following subtests consists of:
# 1. creating tempfile with some contents and **closing it**
# 3. doing some tests (will reopen tempfile)
# 4. removing tempfile (whether the subtest passed or not)
with self.subTest("Try to load valid credentials from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as valid:
valid.write(json.dumps(credentials).encode())
self.gc._credentials_file = os.path.basename(valid.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(valid.name)
with self.subTest("Try to load empty file from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as empty:
empty.write(json.dumps(empty_valid_json).encode())
self.gc._credentials_file = os.path.basename(empty.name)
with self.assertRaises(KeyError):
self.gc._load_credentials()
finally:
os.remove(empty.name)
with self.subTest("Try to load nonsense file from current directory"):
try:
with NamedTemporaryFile(dir=".", delete=False) as nonsense:
nonsense.write(nonsense_str)
self.gc._credentials_file = os.path.basename(nonsense.name)
with self.assertRaises(ValueError):
self.gc._load_credentials()
finally:
os.remove(nonsense.name)
with self.subTest("Try to load valid credentials from home directory"):
try:
with NamedTemporaryFile(dir=os.path.expanduser("~"), delete=False) as home_file:
home_file.write(json.dumps(credentials).encode())
self.gc._credentials_file = os.path.basename(home_file.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(home_file.name)
with self.subTest("Try to load credentials with password cmd"):
credentials_with_pass_cmd = {
"username": _username, "password_cmd": password_cmd}
try:
with NamedTemporaryFile(dir=".", delete=False) as valid:
valid.write(json.dumps(credentials_with_pass_cmd).encode())
self.gc._credentials_file = os.path.basename(valid.name)
username, password = self.gc._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(valid.name)
with self.subTest("Try to load credentials with invalid password cmd"):
credentials_with_pass_cmd = {
"username": _username, "password_cmd": invalid_cmd}
try:
with NamedTemporaryFile(dir=".", delete=False) as invalid:
invalid.write(json.dumps(credentials_with_pass_cmd).encode())
self.gc._credentials_file = os.path.basename(invalid.name)
with self.assertRaises(CalledProcessError):
self.gc._load_credentials()
finally:
os.remove(invalid.name)
with self.subTest("Try to load credentials with ambiguous password"):
credentials_with_ambiguous_pass = {"username": _username,
"password": _password,
"password_cmd": password_cmd}
try:
with NamedTemporaryFile(dir=".", delete=False) as ambiguous:
ambiguous.write(json.dumps(credentials_with_ambiguous_pass).encode())
self.gc._credentials_file = os.path.basename(ambiguous.name)
with self.assertRaises(KeyError):
self.gc._load_credentials()
finally:
os.remove(ambiguous.name)
self.gc._credentials_file = filename_backup
def setUp(self):
self.gc = Geocaching(session=session)
class TestLoginOperations(unittest.TestCase):
def setUp(self):
self.g = Geocaching()
def test_login(self):
with self.subTest("bad username"):
with self.assertRaises(LoginFailedException):
self.g.login("", "")
with self.subTest("good username"):
self.g.login(_username, _password)
with self.subTest("good username already logged"):
self.g.login(_username, _password)
with self.subTest("bad username automatic logout"):
with self.assertRaises(LoginFailedException):
self.g.login("", "")
def test_get_logged_user(self):
self.g.login(_username, _password)
self.assertEqual(self.g.get_logged_user(), _username)
def test_logout(self):
self.g.login(_username, _password)
self.g.logout()
self.assertIsNone(self.g.get_logged_user())
def tearDown(self):
self.g.logout()
def setUpClass(cls):
cls.gc = Geocaching()
cls.gc.login(_username, _password)
cls.t = Trackable(cls.gc, "TB1KEZ9")
cls.t.load()
def setUp(self):
self.grid = UTFGrid(Geocaching(), 8800, 5574, 14)
self.grid.size = 64
self.cb = GridCoordinateBlock(self.grid)
def setUp(self):
super().setUp()
self.gc = Geocaching(session=self.session)
class TestLoginOperations(unittest.TestCase):
def setUp(self):
self.g = Geocaching()
def test_request(self):
with self.subTest("login needed"):
with self.assertRaises(NotLoggedInException):
self.g._request("/")
def test_login(self):
with self.subTest("bad username"):
with self.assertRaises(LoginFailedException):
self.g.login("0", "0")
with self.subTest("good username"):
self.g.login(_username, _password)
with self.subTest("good username already logged"):
self.g.login(_username, _password)
with self.subTest("bad username automatic logout"):
with self.assertRaises(LoginFailedException):
self.g.login("0", "0")
def test_get_logged_user(self):
self.g.login(_username, _password)
self.assertEqual(self.g.get_logged_user(), _username)
def test_logout(self):
self.g.login(_username, _password)
self.g.logout()
self.assertIsNone(self.g.get_logged_user())
def test_load_credentials(self):
filename_backup = self.g._credentials_file
credentials = {"username": _username, "password": _password}
empty_valid_json = {}
nonsense_str = b"ss{}ef"
with self.subTest("Try to load nonexistent file from current directory"):
self.g._credentials_file = "this_file_doesnt_exist.json"
with self.assertRaises(FileNotFoundError):
username, password = self.g._load_credentials()
# each of the following subtests consists of:
# 1. creating tempfile with some contents and **closing it**
# 3. doing some tests (will reopen tempfile)
# 4. removing tempfile (whether the subtest passed or not)
with self.subTest("Try to load valid credentials from current directory"):
try:
with NamedTemporaryFile(dir='.', delete=False) as valid:
valid.write(json.dumps(credentials).encode())
self.g._credentials_file = os.path.basename(valid.name)
username, password = self.g._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(valid.name)
with self.subTest("Try to load empty file from current directory"):
try:
with NamedTemporaryFile(dir='.', delete=False) as empty:
empty.write(json.dumps(empty_valid_json).encode())
self.g._credentials_file = os.path.basename(empty.name)
with self.assertRaises(KeyError):
username, password = self.g._load_credentials()
finally:
os.remove(empty.name)
with self.subTest("Try to load nonsense file from current directory"):
try:
with NamedTemporaryFile(dir='.', delete=False) as nonsense:
nonsense.write(nonsense_str)
self.g._credentials_file = os.path.basename(nonsense.name)
with self.assertRaises(ValueError):
username, password = self.g._load_credentials()
finally:
os.remove(nonsense.name)
with self.subTest("Try to load valid credentials from home directory"):
try:
with NamedTemporaryFile(dir=os.path.expanduser("~"), delete=False) as home_file:
home_file.write(json.dumps(credentials).encode())
self.g._credentials_file = os.path.basename(home_file.name)
username, password = self.g._load_credentials()
self.assertEqual(_username, username)
self.assertEqual(_password, password)
finally:
os.remove(home_file.name)
self.g._credentials_file = filename_backup
