Updated tests

.gitignore

@@ -3,6 +3,7 @@
 .tox/*
 __pycache__/*
 htmlcov/*
+.coverage
 .coverage.*
 coverage.xml
 *.pyc

blinkpy/camera.py

@@ -110,7 +110,7 @@ class BlinkCamera:
         )
         try:
             self.temperature_calibrated = resp["temp"]
-        except KeyError:
+        except (TypeError, KeyError):
             self.temperature_calibrated = self.temperature
             _LOGGER.warning("Could not retrieve calibrated temperature.")
 

blinkpy/helpers/util.py

@@ -105,17 +105,17 @@ class BlinkAuthenticationException(BlinkException):
 class BlinkURLHandler:
     """Class that handles Blink URLS."""
 
-    def __init__(self, region_id, legacy=False):
+    def __init__(self, region_id):
         """Initialize the urls."""
-        self.subdomain = "rest-{}".format(region_id)
-        if legacy:
-            self.subdomain = "rest.{}".format(region_id)
-        self.base_url = "https://{}.{}".format(self.subdomain, const.BLINK_URL)
-        self.home_url = "{}/homescreen".format(self.base_url)
-        self.event_url = "{}/events/network".format(self.base_url)
-        self.network_url = "{}/network".format(self.base_url)
-        self.networks_url = "{}/networks".format(self.base_url)
-        self.video_url = "{}/api/v2/videos".format(self.base_url)
+        if region_id is None:
+            raise TypeError
+        self.subdomain = f"rest-{region_id}"
+        self.base_url = f"https://{self.subdomain}.{const.BLINK_URL}"
+        self.home_url = f"{self.base_url}/homescreen"
+        self.event_url = f"{self.base_url}/events/network"
+        self.network_url = f"{self.base_url}/network"
+        self.networks_url = f"{self.base_url}/networks"
+        self.video_url = f"{self.base_url}/api/v2/videos"
         _LOGGER.debug("Setting base url to %s.", self.base_url)
 
 

blinkpy/sync_module.py

@@ -25,7 +25,7 @@ class BlinkSyncModule:
         self.region_id = blink.auth.region_id
         self.name = network_name
         self.serial = None
-        self.status = None
+        self.status = "offline"
         self.sync_id = None
         self.host = None
         self.summary = None
@@ -59,7 +59,12 @@ class BlinkSyncModule:
     @property
     def online(self):
         """Return boolean system online status."""
-        return ONLINE[self.status]
+        try:
+            return ONLINE[self.status]
+        except KeyError:
+            _LOGGER.error("Unknown sync module status %s", self.status)
+            self.available = False
+            return False
 
     @property
     def arm(self):
@@ -67,6 +72,7 @@ class BlinkSyncModule:
         try:
             return self.network_info["network"]["armed"]
         except (KeyError, TypeError):
+            self.available = False
             return None
 
     @arm.setter
@@ -159,6 +165,7 @@ class BlinkSyncModule:
             camera_id = self.cameras[camera_name].camera_id
             camera_info = self.get_camera_info(camera_id)
             self.cameras[camera_name].update(camera_info, force_cache=force_cache)
+        self.available = True
 
     def check_new_videos(self):
         """Check if new videos since last refresh."""

tests/test_auth.py

@@ -0,0 +1,214 @@
+"""Test login handler."""
+
+import unittest
+from unittest import mock
+from requests import exceptions
+from blinkpy.auth import Auth, LoginError, TokenRefreshFailed
+import blinkpy.helpers.constants as const
+import tests.mock_responses as mresp
+
+USERNAME = "foobar"
+PASSWORD = "deadbeef"
+
+
+class TestAuth(unittest.TestCase):
+    """Test the Auth class in blinkpy."""
+
+    def setUp(self):
+        """Set up Login Handler."""
+        self.auth = Auth()
+
+    def tearDown(self):
+        """Clean up after test."""
+        self.auth = None
+
+    @mock.patch("blinkpy.helpers.util.gen_uid")
+    @mock.patch("blinkpy.auth.util.getpass")
+    def test_empty_init(self, getpwd, genuid):
+        """Test initialization with no params."""
+        auth = Auth()
+        self.assertDictEqual(auth.data, {})
+        getpwd.return_value = "bar"
+        genuid.return_value = 1234
+        with mock.patch("builtins.input", return_value="foo"):
+            auth.validate_login()
+        expected_data = {
+            "username": "foo",
+            "password": "bar",
+            "uid": 1234,
+            "notification_key": 1234,
+            "device_id": const.DEVICE_ID,
+        }
+        self.assertDictEqual(auth.data, expected_data)
+
+    @mock.patch("blinkpy.helpers.util.gen_uid")
+    @mock.patch("blinkpy.auth.util.getpass")
+    def test_barebones_init(self, getpwd, genuid):
+        """Test basebones initialization."""
+        login_data = {"username": "foo", "password": "bar"}
+        auth = Auth(login_data)
+        self.assertDictEqual(auth.data, login_data)
+        getpwd.return_value = "bar"
+        genuid.return_value = 1234
+        with mock.patch("builtins.input", return_value="foo"):
+            auth.validate_login()
+        expected_data = {
+            "username": "foo",
+            "password": "bar",
+            "uid": 1234,
+            "notification_key": 1234,
+            "device_id": const.DEVICE_ID,
+        }
+        self.assertDictEqual(auth.data, expected_data)
+
+    def test_full_init(self):
+        """Test full initialization."""
+        login_data = {
+            "username": "foo",
+            "password": "bar",
+            "token": "token",
+            "host": "host",
+            "region_id": "region_id",
+            "client_id": "client_id",
+            "account_id": "account_id",
+            "uid": 1234,
+            "notification_key": 4321,
+            "device_id": "device_id",
+        }
+        auth = Auth(login_data)
+        self.assertEqual(auth.token, "token")
+        self.assertEqual(auth.host, "host")
+        self.assertEqual(auth.region_id, "region_id")
+        self.assertEqual(auth.client_id, "client_id")
+        self.assertEqual(auth.account_id, "account_id")
+        auth.validate_login()
+        self.assertDictEqual(auth.login_attributes, login_data)
+
+    def test_bad_response_code(self):
+        """Check bad response code from server."""
+        fake_resp = mresp.MockResponse({"code": 404}, 404)
+        with self.assertRaises(exceptions.ConnectionError):
+            self.auth.validate_response(fake_resp, True)
+
+    def test_good_response_code(self):
+        """Check good response code from server."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 200)
+        self.assertEqual(self.auth.validate_response(fake_resp, True), {"foo": "bar"})
+
+    def test_response_not_json(self):
+        """Check response when not json."""
+        fake_resp = "foobar"
+        self.assertEqual(self.auth.validate_response(fake_resp, False), "foobar")
+
+    def test_header(self):
+        """Test header data."""
+        self.auth.token = "bar"
+        self.auth.host = "foo"
+        expected_header = {"Host": "foo", "TOKEN_AUTH": "bar"}
+        self.assertDictEqual(self.auth.header, expected_header)
+
+    def test_header_no_token(self):
+        """Test header without token."""
+        self.auth.token = None
+        self.assertEqual(self.auth.header, None)
+
+    @mock.patch("blinkpy.auth.Auth.validate_login", return_value=None)
+    @mock.patch("blinkpy.auth.api.request_login")
+    def test_login(self, mock_req, mock_validate):
+        """Test login handling."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 200)
+        mock_req.return_value = fake_resp
+        self.assertEqual(self.auth.login(), {"foo": "bar"})
+
+    @mock.patch("blinkpy.auth.Auth.validate_login", return_value=None)
+    @mock.patch("blinkpy.auth.api.request_login")
+    def test_login_bad_response(self, mock_req, mock_validate):
+        """Test login handling when bad response."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 404)
+        mock_req.return_value = fake_resp
+        with self.assertRaises(LoginError):
+            self.auth.login()
+
+    @mock.patch("blinkpy.auth.Auth.login")
+    def test_refresh_token(self, mock_login):
+        """Test refresh token method."""
+        mock_login.return_value = {
+            "region": {"tier": "test"},
+            "authtoken": {"authtoken": "foobar"},
+            "client": {"id": 1234},
+            "account": {"id": 5678},
+        }
+        self.assertTrue(self.auth.refresh_token())
+        self.assertEqual(self.auth.region_id, "test")
+        self.assertEqual(self.auth.token, "foobar")
+        self.assertEqual(self.auth.client_id, 1234)
+        self.assertEqual(self.auth.account_id, 5678)
+
+    @mock.patch("blinkpy.auth.Auth.login")
+    def test_refresh_token_failed(self, mock_login):
+        """Test refresh token failed."""
+        mock_login.return_value = {}
+        with self.assertRaises(TokenRefreshFailed):
+            self.auth.refresh_token()
+
+    def test_check_key_required(self):
+        """Check key required method."""
+        self.auth.login_response = {}
+        self.assertFalse(self.auth.check_key_required())
+
+        self.auth.login_response = {"client": {"verification_required": False}}
+        self.assertFalse(self.auth.check_key_required())
+
+        self.auth.login_response = {"client": {"verification_required": True}}
+        self.assertTrue(self.auth.check_key_required())
+
+    @mock.patch("blinkpy.auth.api.request_verify")
+    def test_send_auth_key(self, mock_req):
+        """Check sending of auth key."""
+        mock_blink = MockBlink(None)
+        mock_req.return_value = mresp.MockResponse({"valid": True}, 200)
+        self.assertTrue(self.auth.send_auth_key(mock_blink, 1234))
+        self.assertTrue(mock_blink.available)
+
+        mock_req.return_value = mresp.MockResponse(None, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+        mock_req.return_value = mresp.MockResponse({}, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+        self.assertTrue(self.auth.send_auth_key(mock_blink, None))
+
+    @mock.patch("blinkpy.auth.api.request_verify")
+    def test_send_auth_key_fail(self, mock_req):
+        """Check handling of auth key failure."""
+        mock_blink = MockBlink(None)
+        mock_req.return_value = mresp.MockResponse(None, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+        mock_req.return_value = mresp.MockResponse({}, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+    @mock.patch("blinkpy.auth.Auth.validate_response")
+    @mock.patch("blinkpy.auth.Auth.refresh_token")
+    def test_query_retry(self, mock_refresh, mock_validate):
+        """Check handling of request retry."""
+        self.auth.session = MockSession()
+        mock_validate.side_effect = [TokenRefreshFailed, "foobar"]
+        mock_refresh.return_value = True
+        self.assertEqual(self.auth.query(url="http://example.com"), "foobar")
+
+
+class MockSession:
+    """Object to mock a session."""
+
+    def send(self, *args, **kwargs):
+        """Mock send function."""
+        return None
+
+
+class MockBlink:
+    """Object to mock basic blink class."""
+
+    def __init__(self, login_response):
+        """Initialize mock blink class."""
+        self.available = False
+        self.login_response = login_response

tests/test_blink_functions.py

@@ -5,11 +5,7 @@ import logging
 
 from blinkpy import blinkpy
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers.util import create_session, get_time
-import tests.mock_responses as mresp
-
-USERNAME = "foobar"
-PASSWORD = "deadbeef"
+from blinkpy.helpers.util import get_time, BlinkURLHandler
 
 
 class MockSyncModule(BlinkSyncModule):
@@ -34,42 +30,19 @@ class MockSyncModule(BlinkSyncModule):
         return self.return_value
 
 
-@mock.patch("blinkpy.helpers.util.Session.send", side_effect=mresp.mocked_session_send)
 class TestBlinkFunctions(unittest.TestCase):
     """Test Blink and BlinkCamera functions in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(username=USERNAME, password=PASSWORD)
-        # pylint: disable=protected-access
-        self.blink._auth_header = {"Host": "test.url.tld", "TOKEN_AUTH": "foobar123"}
-        self.blink.urls = blinkpy.BlinkURLHandler("test")
-        self.blink.session = create_session()
+        self.blink = blinkpy.Blink()
+        self.blink.urls = BlinkURLHandler("test")
 
     def tearDown(self):
         """Clean up after test."""
         self.blink = None
 
-    @mock.patch("blinkpy.login_handler.api.request_login")
-    def test_backup_url(self, req, mock_sess):
-        """Test backup login method."""
-        json_resp = {
-            "authtoken": {"authtoken": "foobar123"},
-            "networks": {"1234": {"name": "foobar", "onboarded": True}},
-        }
-        bad_req = mresp.MockResponse({}, 404)
-        new_req = mresp.MockResponse(json_resp, 200)
-        req.side_effect = [bad_req, bad_req, new_req]
-        self.blink.login_handler.login_urls = ["test1", "test2", "test3"]
-        self.blink.login_handler.login(self.blink)
-        self.assertEqual(self.blink.login_handler.login_url, "test3")
-
-        req.side_effect = [bad_req, new_req, bad_req]
-        self.blink.login_handler.login_urls = ["test1", "test2", "test3"]
-        self.blink.login_handler.login(self.blink)
-        self.assertEqual(self.blink.login_handler.login_url, "test2")
-
-    def test_merge_cameras(self, mock_sess):
+    def test_merge_cameras(self):
         """Test merge camera functionality."""
         first_dict = {"foo": "bar", "test": 123}
         next_dict = {"foobar": 456, "bar": "foo"}
@@ -82,7 +55,7 @@ class TestBlinkFunctions(unittest.TestCase):
         self.assertEqual(expected, result)
 
     @mock.patch("blinkpy.blinkpy.api.request_videos")
-    def test_download_video_exit(self, mock_req, mock_sess):
+    def test_download_video_exit(self, mock_req):
         """Test we exit method when provided bad response."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access
@@ -100,7 +73,7 @@ class TestBlinkFunctions(unittest.TestCase):
         self.assertEqual(dl_log.output, expected_log)
 
     @mock.patch("blinkpy.blinkpy.api.request_videos")
-    def test_parse_downloaded_items(self, mock_req, mock_sess):
+    def test_parse_downloaded_items(self, mock_req):
         """Test ability to parse downloaded items list."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access
@@ -125,7 +98,7 @@ class TestBlinkFunctions(unittest.TestCase):
         self.assertEqual(dl_log.output, expected_log)
 
     @mock.patch("blinkpy.blinkpy.api.request_videos")
-    def test_parse_camera_not_in_list(self, mock_req, mock_sess):
+    def test_parse_camera_not_in_list(self, mock_req):
         """Test ability to parse downloaded items list."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access

tests/test_blinkpy.py

@@ -8,96 +8,57 @@ any communication related errors at startup.
 
 import unittest
 from unittest import mock
-from blinkpy import api
-from blinkpy.blinkpy import Blink
-from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.login_handler import LoginHandler
-from blinkpy.helpers.util import (
-    http_req,
-    create_session,
-    BlinkException,
-    BlinkURLHandler,
-)
+from blinkpy.blinkpy import Blink, BlinkSetupError
 from blinkpy.helpers.constants import __version__
-import tests.mock_responses as mresp
-
-USERNAME = "foobar"
-PASSWORD = "deadbeef"
 
 
-@mock.patch("blinkpy.helpers.util.Session.send", side_effect=mresp.mocked_session_send)
 class TestBlinkSetup(unittest.TestCase):
     """Test the Blink class in blinkpy."""
 
     def setUp(self):
-        """Set up Blink module."""
-        self.blink = Blink(username=USERNAME, password=PASSWORD)
-        self.blink.sync["test"] = BlinkSyncModule(self.blink, "test", "1234", [])
-        self.blink.urls = BlinkURLHandler("test")
-        self.blink.session = create_session()
+        """Initialize blink test object."""
+        self.blink = Blink()
+        self.blink.available = True
 
     def tearDown(self):
-        """Clean up after test."""
+        """Cleanup blink test object."""
         self.blink = None
 
-    def test_initialization(self, mock_sess):
+    def test_initialization(self):
         """Verify we can initialize blink."""
-        self.assertEqual(self.blink.version, __version__)
-        self.assertEqual(self.blink.login_handler.data["username"], USERNAME)
-        self.assertEqual(self.blink.login_handler.data["password"], PASSWORD)
+        blink = Blink()
+        self.assertEqual(blink.version, __version__)
 
-    def test_bad_request(self, mock_sess):
-        """Check that we raise an Exception with a bad request."""
-        self.blink.session = create_session()
-        explog = "WARNING:blinkpy.helpers.util:" "Response from server: 200 - foo"
-        with self.assertRaises(BlinkException):
-            http_req(self.blink, reqtype="bad")
+    def test_network_id_failure(self):
+        """Check that with bad network data a setup error is raised."""
+        self.blink.networks = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_network_ids()
 
-        with self.assertLogs() as logrecord:
-            http_req(self.blink, reqtype="post", is_retry=True)
-        self.assertEqual(logrecord.output, [explog])
-
-    def test_authentication(self, mock_sess):
-        """Check that we can authenticate Blink up properly."""
-        authtoken = self.blink.get_auth_token()["TOKEN_AUTH"]
-        expected = mresp.LOGIN_RESPONSE["authtoken"]["authtoken"]
-        self.assertEqual(authtoken, expected)
-
-    def test_reauthorization_attempt(self, mock_sess):
-        """Check that we can reauthorize after first unsuccessful attempt."""
-        original_header = self.blink.get_auth_token()
-        # pylint: disable=protected-access
-        bad_header = {"Host": self.blink._host, "TOKEN_AUTH": "BADTOKEN"}
-        # pylint: disable=protected-access
-        self.blink._auth_header = bad_header
-        self.assertEqual(self.blink.auth_header, bad_header)
-        api.request_homescreen(self.blink)
-        self.assertEqual(self.blink.auth_header, original_header)
-
-    def test_multiple_networks(self, mock_sess):
+    def test_multiple_networks(self):
         """Check that we handle multiple networks appropriately."""
         self.blink.networks = {
             "0000": {"onboarded": False, "name": "foo"},
             "5678": {"onboarded": True, "name": "bar"},
             "1234": {"onboarded": False, "name": "test"},
         }
-        self.blink.get_ids()
+        self.blink.setup_network_ids()
         self.assertTrue("5678" in self.blink.network_ids)
 
-    def test_multiple_onboarded_networks(self, mock_sess):
+    def test_multiple_onboarded_networks(self):
         """Check that we handle multiple networks appropriately."""
         self.blink.networks = {
             "0000": {"onboarded": False, "name": "foo"},
             "5678": {"onboarded": True, "name": "bar"},
             "1234": {"onboarded": True, "name": "test"},
         }
-        self.blink.get_ids()
+        self.blink.setup_network_ids()
         self.assertTrue("0000" not in self.blink.network_ids)
         self.assertTrue("5678" in self.blink.network_ids)
         self.assertTrue("1234" in self.blink.network_ids)
 
     @mock.patch("blinkpy.blinkpy.time.time")
-    def test_throttle(self, mock_time, mock_sess):
+    def test_throttle(self, mock_time):
         """Check throttling functionality."""
         now = self.blink.refresh_rate + 1
         mock_time.return_value = now
@@ -113,19 +74,15 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(self.blink.check_if_ok_to_update(), False)
         self.assertEqual(self.blink.last_refresh, now)
 
-    def test_sync_case_insensitive_dict(self, mock_sess):
+    def test_sync_case_insensitive_dict(self):
         """Check that we can access sync modules ignoring case."""
-        self.assertEqual(self.blink.sync["test"].name, "test")
-        self.assertEqual(self.blink.sync["TEST"].name, "test")
-
-    @mock.patch("blinkpy.api.request_login")
-    def test_unexpected_login(self, mock_login, mock_sess):
-        """Check that we appropriately handle unexpected login info."""
-        mock_login.return_value = None
-        self.assertFalse(self.blink.get_auth_token())
+        self.blink.sync["test"] = 1234
+        self.assertEqual(self.blink.sync["test"], 1234)
+        self.assertEqual(self.blink.sync["TEST"], 1234)
+        self.assertEqual(self.blink.sync["tEsT"], 1234)
 
     @mock.patch("blinkpy.api.request_homescreen")
-    def test_get_cameras(self, mock_home, mock_sess):
+    def test_setup_cameras(self, mock_home):
         """Check retrieval of camera information."""
         mock_home.return_value = {
             "cameras": [
@@ -134,7 +91,7 @@ class TestBlinkSetup(unittest.TestCase):
                 {"name": "test", "network_id": 4321, "id": 0000},
             ]
         }
-        result = self.blink.get_cameras()
+        result = self.blink.setup_camera_list()
         self.assertEqual(
             result,
             {
@@ -144,28 +101,34 @@ class TestBlinkSetup(unittest.TestCase):
         )
 
     @mock.patch("blinkpy.api.request_homescreen")
-    def test_get_cameras_failure(self, mock_home, mock_sess):
-        """Check that on failure we initialize empty info and move on."""
+    def test_setup_cameras_failure(self, mock_home):
+        """Check that on failure we raise a setup error."""
         mock_home.return_value = {}
-        result = self.blink.get_cameras()
-        self.assertEqual(result, {})
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_camera_list()
 
-    @mock.patch.object(LoginHandler, "send_auth_key")
-    @mock.patch.object(Blink, "setup_post_verify")
-    def test_startup_prompt(self, mock_send_key, mock_verify, mock_sess):
-        """Test startup logic with command-line prompt."""
-        mock_send_key.return_value = True
-        mock_verify.return_value = True
-        self.blink.no_prompt = False
-        self.blink.key_required = True
-        self.blink.available = True
-        with mock.patch("builtins.input", return_value="1234"):
-            self.blink.start()
-        self.assertFalse(self.blink.key_required)
+    def test_setup_urls(self):
+        """Check setup of URLS."""
+        self.blink.auth.region_id = "test"
+        self.blink.setup_urls()
+        self.assertEqual(self.blink.urls.subdomain, "rest-test")
 
-    def test_startup_no_prompt(self, mock_sess):
-        """Test startup with no_prompt flag set."""
-        self.blink.key_required = True
-        self.blink.no_prompt = True
-        self.blink.start()
-        self.assertTrue(self.blink.key_required)
+    def test_setup_urls_failure(self):
+        """Check that on failure we raise a setup error."""
+        self.blink.auth.region_id = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_urls()
+
+    @mock.patch("blinkpy.api.request_networks")
+    def test_setup_networks(self, mock_networks):
+        """Check setup of networks."""
+        mock_networks.return_value = {"summary": "foobar"}
+        self.blink.setup_networks()
+        self.assertEqual(self.blink.networks, "foobar")
+
+    @mock.patch("blinkpy.api.request_networks")
+    def test_setup_networks_failure(self, mock_networks):
+        """Check that on failure we raise a setup error."""
+        mock_networks.return_value = {}
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_networks()

tests/test_cameras.py

@@ -8,14 +8,11 @@ Blink system is set up.
 
 import unittest
 from unittest import mock
-from blinkpy import blinkpy
-from blinkpy.helpers.util import create_session, BlinkURLHandler
+from blinkpy.blinkpy import Blink
+from blinkpy.helpers.util import BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.camera import BlinkCamera
-import tests.mock_responses as mresp
 
-USERNAME = "foobar"
-PASSWORD = "deadbeef"
 
 CAMERA_CFG = {
     "camera": [
@@ -29,20 +26,13 @@ CAMERA_CFG = {
 }
 
 
-@mock.patch("blinkpy.helpers.util.Session.send", side_effect=mresp.mocked_session_send)
+@mock.patch("blinkpy.auth.Auth.query")
 class TestBlinkCameraSetup(unittest.TestCase):
     """Test the Blink class in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(username=USERNAME, password=PASSWORD)
-        header = {
-            "Host": "abc.zxc",
-            "TOKEN_AUTH": mresp.LOGIN_RESPONSE["authtoken"]["authtoken"],
-        }
-        # pylint: disable=protected-access
-        self.blink._auth_header = header
-        self.blink.session = create_session()
+        self.blink = Blink()
         self.blink.urls = BlinkURLHandler("test")
         self.blink.sync["test"] = BlinkSyncModule(self.blink, "test", 1234, [])
         self.camera = BlinkCamera(self.blink.sync["test"])
@@ -52,8 +42,9 @@ class TestBlinkCameraSetup(unittest.TestCase):
     def tearDown(self):
         """Clean up after test."""
         self.blink = None
+        self.camera = None
 
-    def test_camera_update(self, mock_sess):
+    def test_camera_update(self, mock_resp):
         """Test that we can properly update camera properties."""
         config = {
             "name": "new",
@@ -71,8 +62,8 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.camera.sync.last_record = {
             "new": {"clip": "/test.mp4", "time": "1970-01-01T00:00:00"}
         }
-        mock_sess.side_effect = [
-            mresp.MockResponse({"temp": 71}, 200),
+        mock_resp.side_effect = [
+            {"temp": 71},
             "test",
             "foobar",
         ]
@@ -96,9 +87,9 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.assertEqual(self.camera.image_from_cache, "test")
         self.assertEqual(self.camera.video_from_cache, "foobar")
 
-    def test_no_thumbnails(self, mock_sess):
+    def test_no_thumbnails(self, mock_resp):
         """Tests that thumbnail is 'None' if none found."""
-        mock_sess.return_value = "foobar"
+        mock_resp.return_value = "foobar"
         self.camera.last_record = ["1"]
         config = {
             "name": "new",
@@ -133,9 +124,9 @@ class TestBlinkCameraSetup(unittest.TestCase):
             ],
         )
 
-    def test_no_video_clips(self, mock_sess):
+    def test_no_video_clips(self, mock_resp):
         """Tests that we still proceed with camera setup with no videos."""
-        mock_sess.return_value = "foobar"
+        mock_resp.return_value = "foobar"
         config = {
             "name": "new",
             "id": 1234,

tests/test_login_handler.py

@@ -1,135 +0,0 @@
-"""Test login handler."""
-
-import unittest
-from unittest import mock
-from blinkpy.login_handler import LoginHandler
-import tests.mock_responses as mresp
-
-USERNAME = "foobar"
-PASSWORD = "deadbeef"
-
-
-@mock.patch("blinkpy.helpers.util.Session.send", side_effect=mresp.mocked_session_send)
-class TestLoginHandler(unittest.TestCase):
-    """Test the LoginHandler class in blinkpy."""
-
-    def setUp(self):
-        """Set up Login Handler."""
-        self.login_handler = LoginHandler()
-
-    def tearDown(self):
-        """Clean up after test."""
-        self.login_handler = None
-
-    @mock.patch("blinkpy.login_handler.getpass")
-    def test_manual_login(self, getpwd, mock_sess):
-        """Check that we can manually use the login() function."""
-        getpwd.return_value = PASSWORD
-        with mock.patch("builtins.input", return_value=USERNAME):
-            self.assertTrue(self.login_handler.check_login())
-        self.assertEqual(self.login_handler.data["username"], USERNAME)
-        self.assertEqual(self.login_handler.data["password"], PASSWORD)
-
-    def test_no_cred_file(self, mock_sess):
-        """Check that we return false when cred file doesn't exist."""
-        self.login_handler.cred_file = "/tmp/fake.file"
-        self.assertFalse(self.login_handler.check_cred_file())
-
-    @mock.patch("blinkpy.login_handler.isfile")
-    def test_exit_on_missing_json(self, mockisfile, mock_sess):
-        """Test that we fail on missing json data."""
-        self.login_handler.cred_file = "/tmp/fake.file"
-        mockisfile.return_value = True
-        with mock.patch("builtins.open", mock.mock_open(read_data="{}")):
-            self.assertFalse(self.login_handler.check_cred_file())
-
-    @mock.patch("blinkpy.login_handler.json.load")
-    @mock.patch("blinkpy.login_handler.isfile")
-    def test_cred_file(self, mockisfile, mockjson, mock_sess):
-        """Test that loading credential file works."""
-        self.login_handler.cred_file = "/tmp/fake.file"
-        mockjson.return_value = {"username": "foo", "password": "bar"}
-        mockisfile.return_value = True
-        with mock.patch("builtins.open", mock.mock_open(read_data="")):
-            self.assertTrue(self.login_handler.check_cred_file())
-        self.assertEqual(self.login_handler.data["username"], "foo")
-        self.assertEqual(self.login_handler.data["password"], "bar")
-
-    def test_bad_response(self, mock_sess):
-        """Check bad response from server."""
-        self.assertFalse(self.login_handler.validate_response(None, None))
-
-    def test_bad_response_code(self, mock_sess):
-        """Check bad response code from server."""
-        fake_resp = mresp.MockResponse(None, 404)
-        self.assertFalse(self.login_handler.validate_response(None, fake_resp))
-
-    def test_good_response_code(self, mock_sess):
-        """Check good response code from server."""
-        fake_resp = mresp.MockResponse(None, 200)
-        self.assertTrue(self.login_handler.validate_response(None, fake_resp))
-
-    @mock.patch("blinkpy.login_handler.util.gen_uid")
-    def test_check_keys_no_persist(self, mock_uid, mock_sess):
-        """Check key generation."""
-        uid_value = "abc123"
-        mock_uid.return_value = "abc123"
-        self.login_handler.persist_key = None
-        data = self.login_handler.check_keys()
-        self.assertEqual(data["uid"], uid_value)
-        self.assertEqual(data["notification_key"], uid_value)
-
-    @mock.patch("blinkpy.login_handler.util.gen_uid")
-    @mock.patch("blinkpy.login_handler.json.load")
-    @mock.patch("blinkpy.login_handler.isfile")
-    def test_check_keys_persist(self, mockisfile, mockjson, mock_uid, mock_sess):
-        """Check key load from file."""
-        uid_value = "abc123"
-        mock_file = {"uid": "321cba", "notification_key": "foobar123"}
-        mock_uid.return_value = uid_value
-        mockjson.return_value = mock_file
-        mockisfile.return_value = True
-        self.login_handler.persist_key = True
-        data = self.login_handler.check_keys()
-        self.assertEqual(mock_file["uid"], data["uid"])
-        self.assertEqual(mock_file["notification_key"], data["notification_key"])
-
-    def test_check_key_required(self, mock_sess):
-        """Check key required method."""
-        response_true = {"client": {"verification_required": True}}
-        response_false = {"client": {"verification_required": False}}
-        response_nokey = {}
-
-        mock_blink = MockBlink(response_nokey)
-        self.assertFalse(self.login_handler.check_key_required(mock_blink))
-
-        mock_blink = MockBlink(response_false)
-        self.assertFalse(self.login_handler.check_key_required(mock_blink))
-
-        mock_blink = MockBlink(response_true)
-        self.assertTrue(self.login_handler.check_key_required(mock_blink))
-
-    @mock.patch("blinkpy.login_handler.api.request_verify")
-    def test_send_auth_key(self, mock_req, mock_sess):
-        """Check sending of auth key."""
-        mock_blink = MockBlink(None)
-        mock_req.return_value = mresp.MockResponse({"valid": True}, 200)
-        self.assertTrue(self.login_handler.send_auth_key(mock_blink, 1234))
-        self.assertTrue(mock_blink.available)
-
-        mock_req.return_value = mresp.MockResponse(None, 200)
-        self.assertFalse(self.login_handler.send_auth_key(mock_blink, 1234))
-
-        mock_req.return_value = mresp.MockResponse({}, 200)
-        self.assertFalse(self.login_handler.send_auth_key(mock_blink, 1234))
-
-        self.assertTrue(self.login_handler.send_auth_key(mock_blink, None))
-
-
-class MockBlink:
-    """Object to mock basic blink class."""
-
-    def __init__(self, login_response):
-        """Initialize mock blink class."""
-        self.available = False
-        self.login_response = login_response

tests/test_sync_module.py

@@ -2,27 +2,21 @@
 import unittest
 from unittest import mock
 
-from blinkpy import blinkpy
+from blinkpy.blinkpy import Blink
+from blinkpy.helpers.util import BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.camera import BlinkCamera
 
-USERNAME = "foobar"
-PASSWORD = "deadbeef"
 
-
-@mock.patch("blinkpy.api.http_req")
+@mock.patch("blinkpy.auth.Auth.query")
 class TestBlinkSyncModule(unittest.TestCase):
     """Test BlinkSyncModule functions in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(
-            username=USERNAME, password=PASSWORD, motion_interval=0
-        )
-        # pylint: disable=protected-access
-        self.blink._auth_header = {"Host": "test.url.tld", "TOKEN_AUTH": "foobar123"}
+        self.blink = Blink(motion_interval=0)
         self.blink.last_refresh = 0
-        self.blink.urls = blinkpy.BlinkURLHandler("test")
+        self.blink.urls = BlinkURLHandler("test")
         self.blink.sync["test"] = BlinkSyncModule(self.blink, "test", "1234", [])
         self.camera = BlinkCamera(self.blink.sync)
         self.mock_start = [
@@ -48,6 +42,24 @@ class TestBlinkSyncModule(unittest.TestCase):
         self.camera = None
         self.mock_start = None
 
+    def test_bad_status(self, mock_resp):
+        """Check that we mark module unavaiable on bad status."""
+        self.blink.sync["test"].status = None
+        self.blink.sync["test"].available = True
+        self.assertFalse(self.blink.sync["test"].online)
+        self.assertFalse(self.blink.sync["test"].available)
+
+    def test_bad_arm(self, mock_resp):
+        """Check that we mark module unavaiable if bad arm status."""
+        self.blink.sync["test"].network_info = None
+        self.blink.sync["test"].available = True
+        self.assertEqual(self.blink.sync["test"].arm, None)
+        self.assertFalse(self.blink.sync["test"].available)
+        self.blink.sync["test"].network_info = {}
+        self.blink.sync["test"].available = True
+        self.assertEqual(self.blink.sync["test"].arm, None)
+        self.assertFalse(self.blink.sync["test"].available)
+
     def test_get_events(self, mock_resp):
         """Test get events function."""
         mock_resp.return_value = {"event": True}

tests/test_util.py

@@ -3,7 +3,7 @@
 import unittest
 from unittest import mock
 import time
-from blinkpy.helpers.util import Throttle, BlinkURLHandler, time_to_seconds
+from blinkpy.helpers.util import Throttle, time_to_seconds
 
 
 class TestUtil(unittest.TestCase):
@@ -101,13 +101,6 @@ class TestUtil(unittest.TestCase):
             self.assertEqual(tester.test1(), None)
             self.assertEqual(tester.test2(), True)
 
-    def test_legacy_subdomains(self):
-        """Test that subdomain can be set to legacy mode."""
-        urls = BlinkURLHandler("test")
-        self.assertEqual(urls.subdomain, "rest-test")
-        urls = BlinkURLHandler("test", legacy=True)
-        self.assertEqual(urls.subdomain, "rest.test")
-
     def test_time_to_seconds(self):
         """Test time to seconds conversion."""
         correct_time = "1970-01-01T00:00:05+00:00"