Ignore nones in login for supermicro

drzal · drzal · commit ed7b5ad4e6cc · 2025-04-08T11:29:37.000-04:00
diff --git a/.gitignore b/.gitignore
@@ -7,3 +7,4 @@ htmlcov
 dist
 build/
 Pipfile.lock
+.vscode
diff --git a/Makefile b/Makefile
@@ -17,7 +17,8 @@ coverage:
 	xdg-open htmlcov/index.html
 
 lint:
-	pipenv run ruff redfish_client
+	pipenv run ruff check redfish_client tests --fix
+	pipenv run ruff format redfish_client tests
 
 publish:
 	rm -rf dist/*
diff --git a/redfish_client/__init__.py b/redfish_client/__init__.py
@@ -17,8 +17,15 @@
 from redfish_client.root import Root
 
 
-def connect(base_url, username, password, verify=True, cache=True,
-            lazy_load=True, timeout=Connector.DEFAULT_TIMEOUT):
+def connect(
+    base_url,
+    username,
+    password,
+    verify=True,
+    cache=True,
+    lazy_load=True,
+    timeout=Connector.DEFAULT_TIMEOUT,
+):
     klass = CachingConnector if cache else Connector
     connector = klass(base_url, username, password, verify=verify, timeout=timeout)
     root = Root(connector, oid="/redfish/v1", lazy=lazy_load)
diff --git a/redfish_client/connector.py b/redfish_client/connector.py
@@ -29,10 +29,7 @@
 class Connector:
     # Default headers, as required by Redfish spec
     # https://redfish.dmtf.org/schemas/DSP0266_1.5.0.html#request-headers
-    DEFAULT_HEADERS = {
-        "Accept": "application/json",
-        "OData-Version": "4.0"
-    }
+    DEFAULT_HEADERS = {"Accept": "application/json", "OData-Version": "4.0"}
     DEFAULT_TIMEOUT = 1  # In seconds
 
     def __init__(self, base_url, username, password, verify=True, timeout=DEFAULT_TIMEOUT):
@@ -55,33 +52,37 @@ def _url(self, path):
 
     def _log_request(self, method, path, payload, headers):
         try:
-            logger.debug(json.dumps(dict(
-                request=dict(
-                    method=method,
-                    base_url=self._base_url,
-                    path=path,
-                    payload=payload,
-                    headers=headers,
+            logger.debug(
+                json.dumps(
+                    dict(
+                        request=dict(
+                            method=method,
+                            base_url=self._base_url,
+                            path=path,
+                            payload=payload,
+                            headers=headers,
+                        )
+                    )
                 )
-            )))
+            )
         except Exception as e:
             logger.error(e)
 
     def _log_response(self, method, path, response, json_data):
         try:
-            logger.debug(json.dumps(dict(
-                request_data=dict(
-                    method=method,
-                    base_url=self._base_url,
-                    path=path
-                ),
-                response=dict(
-                    status_code=response.status_code,
-                    headers=dict(response.headers.lower_items()),
-                    content=str(response.content),
-                    json_data=json_data
+            logger.debug(
+                json.dumps(
+                    dict(
+                        request_data=dict(method=method, base_url=self._base_url, path=path),
+                        response=dict(
+                            status_code=response.status_code,
+                            headers=dict(response.headers.lower_items()),
+                            content=str(response.content),
+                            json_data=json_data,
+                        ),
+                    )
                 )
-            )))
+            )
         except Exception as e:
             logger.error(e)
 
@@ -94,25 +95,16 @@ def _request(self, method, path, payload=None, headers=None, data=None, files=No
             args["files"] = files
         try:
             resp = self._client.request(
-                method,
-                self._url(path),
-                **args,
-                headers=headers,
-                timeout=self._timeout
+                method, self._url(path), **args, headers=headers, timeout=self._timeout
             )
         except requests.exceptions.ConnectionError:
-            raise InaccessibleException(
-                "Endpoint at {} is not accessible".format(self._base_url))
+            raise InaccessibleException("Endpoint at {} is not accessible".format(self._base_url))
 
         if resp.status_code == 401:
             self._unset_header("x-auth-token")
             self.login()
             resp = self._client.request(
-                method,
-                self._url(path),
-                **args,
-                headers=headers,
-                timeout=self._timeout
+                method, self._url(path), **args, headers=headers, timeout=self._timeout
             )
 
         try:
@@ -159,9 +151,14 @@ def _has_session_support(self):
         return bool(self._session_path)
 
     def _session_login(self):
-        resp = self._client.post(self._url(self._session_path), json=dict(
-            UserName=self._username, Password=self._password,
-        ), timeout=self._timeout)
+        resp = self._client.post(
+            self._url(self._session_path),
+            json=dict(
+                UserName=self._username,
+                Password=self._password,
+            ),
+            timeout=self._timeout,
+        )
         if resp.status_code not in [201, 204]:
             raise AuthException("Cannot create session: {}".format(resp.text))
 
@@ -189,12 +186,13 @@ def _session_logout(self):
         self._unset_header("x-auth-token")
 
     def _basic_login(self):
-        secret = "Basic {}".format(base64.b64encode(
-            "{}:{}".format(self._username, self._password).encode("ascii"),
-        ).decode("ascii"))
+        secret = "Basic {}".format(
+            base64.b64encode(
+                "{}:{}".format(self._username, self._password).encode("ascii"),
+            ).decode("ascii")
+        )
         resp = self._client.get(
-            self._url(self._basic_path), headers=dict(authorization=secret),
-            timeout=self._timeout
+            self._url(self._basic_path), headers=dict(authorization=secret), timeout=self._timeout
         )
         if resp.status_code != 200:
             raise AuthException("Invalid credentials")
diff --git a/redfish_client/resource.py b/redfish_client/resource.py
@@ -82,9 +82,7 @@ def _build(self, data):
 
     def _build_from_hash(self, data):
         if "@odata.id" in data:
-            return Resource(
-                self._connector, oid=data["@odata.id"], lazy=self._is_lazy
-            )
+            return Resource(self._connector, oid=data["@odata.id"], lazy=self._is_lazy)
         return Resource(self._connector, data=data, lazy=self._is_lazy)
 
     def refresh(self):
@@ -134,7 +132,7 @@ def jp(self):
         return json.dumps(self.raw, indent=4, sort_keys=True)
 
     def find_object(self, key):
-        """ Recursively search for a key and return key's content """
+        """Recursively search for a key and return key's content"""
         if key in self._get_content().keys():
             return self[key]
 
@@ -160,8 +158,12 @@ def execute_action(self, action_name, payload):
         raise KeyError("Action with {} does not exist".format(action_name))
 
     def wait_for(
-            self, stat, expected, blacklisted=None, poll_interval=3,
-            timeout=15,
+        self,
+        stat,
+        expected,
+        blacklisted=None,
+        poll_interval=3,
+        timeout=15,
     ):
         """
         :param stat: list or tuple of keys
@@ -191,9 +193,7 @@ def wait_for(
                     "Detected blacklisted value '{}'".format(actual_value)
                 )
             time.sleep(poll_interval)
-        raise TimedOutException(
-            "Could not wait for stat {} in time".format(stat)
-        )
+        raise TimedOutException("Could not wait for stat {} in time".format(stat))
 
     @property
     def raw(self):
diff --git a/redfish_client/root.py b/redfish_client/root.py
@@ -20,7 +20,11 @@ def login(self):
         content = self._get_content()
         sessions = content.get("Links", {}).get("Sessions", {})
         authenticated_path = next(
-            i["@odata.id"] for i in content.values() if "@odata.id" in i
+            # supermicro can send none here which causes this to blow up,
+            # so we need to check that we actually have a value
+            i["@odata.id"]
+            for i in content.values()
+            if i and "@odata.id" in i
         )
         if "@odata.id" in sessions:
             self._connector.set_session_auth_data(sessions["@odata.id"])
diff --git a/ruff.toml b/ruff.toml
@@ -1,4 +1,4 @@
-select = [
+lint.select = [
     "B",    # bugbear: https://beta.ruff.rs/docs/rules/#flake8-bugbear-b
     "DJ",   # django: https://beta.ruff.rs/docs/rules/#flake8-django-dj
     "E",    # errors: https://beta.ruff.rs/docs/rules/#error-e
@@ -14,7 +14,7 @@ select = [
 ]
 line-length = 100
 target-version = "py311"
-ignore = [
+lint.ignore = [
     "PLR2004",  # Constants
     "B904",     # Raising exceptions "from"
     "PLR0913",  # Too many arguments
diff --git a/tests/test_caching_connector.py b/tests/test_caching_connector.py
@@ -18,19 +18,25 @@
 
 class TestGet:
     def test_get_caching_ok(self, requests_mock):
-        requests_mock.get("https://demo.dev/data", [
-            dict(status_code=200, json=dict(hello="fish")),
-            dict(status_code=200, json=dict(solong="fish")),
-        ])
+        requests_mock.get(
+            "https://demo.dev/data",
+            [
+                dict(status_code=200, json=dict(hello="fish")),
+                dict(status_code=200, json=dict(solong="fish")),
+            ],
+        )
         conn = CachingConnector("https://demo.dev", None, None)
         assert conn.get("/data").json == dict(hello="fish")
         assert conn.get("/data").json == dict(hello="fish")
 
     def test_get_caching_non_ok(self, requests_mock):
-        requests_mock.get("https://demo.dev/data", [
-            dict(status_code=404, json=dict(error="bad")),
-            dict(status_code=500, json=dict(really="bad")),
-        ])
+        requests_mock.get(
+            "https://demo.dev/data",
+            [
+                dict(status_code=404, json=dict(error="bad")),
+                dict(status_code=500, json=dict(really="bad")),
+            ],
+        )
         conn = CachingConnector("https://demo.dev", None, None)
         assert conn.get("/data").json == dict(error="bad")
         assert conn.get("/data").json == dict(really="bad")
@@ -39,14 +45,20 @@ def test_get_caching_non_ok(self, requests_mock):
 class TestReset:
     @staticmethod
     def mock_paths(mock):
-        mock.get("https://demo.dev/1", [
-            dict(status_code=200, json=dict(hello="fish")),
-            dict(status_code=200, json=dict(hello="bear")),
-        ])
-        mock.get("https://demo.dev/2", [
-            dict(status_code=200, json=dict(solong="fish")),
-            dict(status_code=200, json=dict(solong="bear")),
-        ])
+        mock.get(
+            "https://demo.dev/1",
+            [
+                dict(status_code=200, json=dict(hello="fish")),
+                dict(status_code=200, json=dict(hello="bear")),
+            ],
+        )
+        mock.get(
+            "https://demo.dev/2",
+            [
+                dict(status_code=200, json=dict(solong="fish")),
+                dict(status_code=200, json=dict(solong="bear")),
+            ],
+        )
 
     def test_reset_all(self, requests_mock):
         self.mock_paths(requests_mock)
diff --git a/tests/test_connect.py b/tests/test_connect.py
@@ -0,0 +1,40 @@
+from redfish_client import connect
+
+
+def test_connect(requests_mock):
+    requests_mock.get(
+        "https://demo.dev/redfish/v1",
+        status_code=200,
+        json={
+            "Chassis": {"@odata.id": "/redfish/v1/Chassis"},
+            "Links": {"Sessions": {"@odata.id": "/redfish/v1/SessionService/Sessions"}},
+        },
+    )
+    requests_mock.post(
+        "https://demo.dev/redfish/v1/SessionService/Sessions",
+        status_code=201,
+        headers={"X-Auth-Token": "fake-token", "Location": "fake-location"},
+        json=dict(hello="fish3"),
+    )
+    conn = connect("https://demo.dev/", "user", "pass")
+    assert conn
+
+
+def test_connect_nulls(requests_mock):
+    requests_mock.get(
+        "https://demo.dev/redfish/v1",
+        status_code=200,
+        json={
+            "foo": None,
+            "Chassis": {"@odata.id": "/redfish/v1/Chassis"},
+            "Links": {"Sessions": {"@odata.id": "/redfish/v1/SessionService/Sessions"}},
+        },
+    )
+    requests_mock.post(
+        "https://demo.dev/redfish/v1/SessionService/Sessions",
+        status_code=201,
+        headers={"X-Auth-Token": "fake-token", "Location": "fake-location"},
+        json=dict(hello="fish3"),
+    )
+    conn = connect("https://demo.dev/", "user", "pass")
+    assert conn
diff --git a/tests/test_connector.py b/tests/test_connector.py
diff --git a/tests/test_resource.py b/tests/test_resource.py

-Original file line number
+Diff line change
 dist
 build/
 Pipfile.lock
 +.vscode