Fixed some tox/style/unittest issues

Author: allmightyspiff

.secrets.baseline

@@ -3,7 +3,7 @@
     "files": "^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2024-04-18T01:09:09Z",
+  "generated_at": "2024-04-25T01:18:20Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"
@@ -554,7 +554,7 @@
         "hashed_secret": "a4c805a62a0387010cd172cfed6f6772eb92a5d6",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 76,
+        "line_number": 81,
         "type": "Secret Keyword",
         "verified_result": null
       }

SoftLayer/API.py

@@ -6,9 +6,7 @@
     :license: MIT, see LICENSE for more details.
 """
 # pylint: disable=invalid-name
-import os
 import time
-import warnings
 
 import concurrent.futures as cf
 import json
@@ -148,7 +146,6 @@ def create_client_from_env(username=None,
 
 def employee_client(username=None,
                     access_token=None,
-                    password=None,
                     endpoint_url=None,
                     timeout=None,
                     auth=None,
@@ -159,27 +156,22 @@ def employee_client(username=None,
                     verify=False):
     """Creates an INTERNAL SoftLayer API client using your environment.
 
-    Settings are loaded via keyword arguments, environemtal variables and
-    config file.
+    Settings are loaded via keyword arguments, environemtal variables and config file.
 
     :param username: your user ID
-    :param access_token: hash from SoftLayer_User_Employee::performExternalAuthentication(username, password, 2fa_string)
+    :param access_token: hash from SoftLayer_User_Employee::performExternalAuthentication(username, password, token)
     :param password: password to use for employee authentication
     :param endpoint_url: the API endpoint base URL you wish to connect to.
-        Set this to API_PRIVATE_ENDPOINT to connect via SoftLayer's private
-        network.
+        Set this to API_PRIVATE_ENDPOINT to connect via SoftLayer's private network.
     :param proxy: proxy to be used to make API calls
     :param integer timeout: timeout for API requests
-    :param auth: an object which responds to get_headers() to be inserted into
-        the xml-rpc headers. Example: `BasicAuthentication`
+    :param auth: an object which responds to get_headers() to be inserted into the xml-rpc headers.
+        Example: `BasicAuthentication`
     :param config_file: A path to a configuration file used to load settings
     :param user_agent: an optional User Agent to report when making API
         calls if you wish to bypass the packages built in User Agent string
-    :param transport: An object that's callable with this signature:
-                      transport(SoftLayer.transports.Request)
-    :param bool verify: decide to verify the server's SSL/TLS cert. DO NOT SET
-                        TO FALSE WITHOUT UNDERSTANDING THE IMPLICATIONS.
-
+    :param transport: An object that's callable with this signature: transport(SoftLayer.transports.Request)
+    :param bool verify: decide to verify the server's SSL/TLS cert.
     """
     settings = config.get_client_settings(username=username,
                                           api_key=None,
@@ -214,7 +206,6 @@ def employee_client(username=None,
                 verify=verify,
             )
 
-
     if access_token is None:
         access_token = settings.get('access_token')
 
@@ -241,16 +232,23 @@ class BaseClient(object):
     :param auth: auth driver that looks like SoftLayer.auth.AuthenticationBase
     :param transport: An object that's callable with this signature: transport(SoftLayer.transports.Request)
     """
-
     _prefix = "SoftLayer_"
+    auth: slauth.AuthenticationBase
 
     def __init__(self, auth=None, transport=None, config_file=None):
         if config_file is None:
             config_file = CONFIG_FILE
-        self.auth = auth
         self.config_file = config_file
         self.settings = config.get_config(self.config_file)
+        self.__setAuth(auth)
+        self.__setTransport(transport)
+
+    def __setAuth(self, auth=None):
+        """Prepares the authentication property"""
+        self.auth = auth
 
+    def __setTransport(self, transport=None):
+        """Prepares the transport property"""
         if transport is None:
             url = self.settings['softlayer'].get('endpoint_url')
             if url is not None and '/rest' in url:
@@ -469,6 +467,7 @@ def __repr__(self):
     def __len__(self):
         return 0
 
+
 class CertificateClient(BaseClient):
     """Client that works with a X509 Certificate for authentication.
 
@@ -479,42 +478,20 @@ class CertificateClient(BaseClient):
     """
 
     def __init__(self, auth=None, transport=None, config_file=None):
-        if config_file is None:
-            config_file = CONFIG_FILE
-        self.config_file = config_file
-        self.settings = config.get_config(self.config_file)
+        BaseClient.__init__(self, auth, transport, config_file)
+        self.__setAuth(auth)
 
+    def __setAuth(self, auth=None):
+        """Prepares the authentication property"""
         if auth is None:
             auth_cert = self.settings['softlayer'].get('auth_cert')
             serv_cert = self.settings['softlayer'].get('server_cert', None)
             auth = slauth.X509Authentication(auth_cert, serv_cert)
-        self.auth = auth        
-        
-        
+        self.auth = auth
 
-        if transport is None:
-            url = self.settings['softlayer'].get('endpoint_url')
-            if url is not None and '/rest' in url:
-                # If this looks like a rest endpoint, use the rest transport
-                transport = transports.RestTransport(
-                    endpoint_url=url,
-                    proxy=self.settings['softlayer'].get('proxy'),
-                    # prevents an exception incase timeout is a float number.
-                    timeout=int(self.settings['softlayer'].getfloat('timeout', 0)),
-                    user_agent=consts.USER_AGENT,
-                    verify=self.settings['softlayer'].getboolean('verify'),
-                )
-            else:
-                # Default the transport to use XMLRPC
-                transport = transports.XmlRpcTransport(
-                    endpoint_url=url,
-                    proxy=self.settings['softlayer'].get('proxy'),
-                    timeout=int(self.settings['softlayer'].getfloat('timeout', 0)),
-                    user_agent=consts.USER_AGENT,
-                    verify=self.settings['softlayer'].getboolean('verify'),
-                )
+    def __repr__(self):
+        return "CertificateClient(transport=%r, auth=%r)" % (self.transport, self.auth)
 
-        self.transport = transport
 
 class IAMClient(BaseClient):
     """IBM ID Client for using IAM authentication
@@ -711,9 +688,8 @@ def __init__(self, auth=None, transport=None, config_file=None, account_id=None)
         BaseClient.__init__(self, auth, transport, config_file)
         self.account_id = account_id
 
-
-    def authenticate_with_password(self, username, password, security_token=None):
-        """Performs IBM IAM Username/Password Authentication
+    def authenticate_with_internal(self, username, password, security_token=None):
+        """Performs internal authentication
 
         :param string username: your softlayer username
         :param string password: your softlayer password
@@ -724,12 +700,11 @@ def authenticate_with_password(self, username, password, security_token=None):
         if security_token is None:
             security_token = input("Enter your 2FA Token now: ")
             if len(security_token) != 6:
-                raise Exception("Invalid security token: {}".format(security_token))
+                raise exceptions.SoftLayerAPIError("Invalid security token: {}".format(security_token))
 
         auth_result = self.call('SoftLayer_User_Employee', 'performExternalAuthentication',
                                 username, password, security_token)
 
-
         self.settings['softlayer']['access_token'] = auth_result['hash']
         self.settings['softlayer']['userid'] = str(auth_result['userId'])
         # self.settings['softlayer']['refresh_token'] = tokens['refresh_token']
@@ -739,8 +714,6 @@ def authenticate_with_password(self, username, password, security_token=None):
 
         return auth_result
 
-
-
     def authenticate_with_hash(self, userId, access_token):
         """Authenticates to the Internal SL API with an employee userid + token
 
@@ -791,6 +764,7 @@ def call(self, service, method, *args, **kwargs):
     def __repr__(self):
         return "EmployeeClient(transport=%r, auth=%r)" % (self.transport, self.auth)
 
+
 class Service(object):
     """A SoftLayer Service.
 

SoftLayer/CLI/login.py

@@ -1,28 +1,28 @@
 """Login with your employee username, password, 2fa token"""
 # :license: MIT, see LICENSE for more details.
+import os
 
 import click
-import os 
 
-
-from SoftLayer.API import EmployeeClient
 from SoftLayer.CLI.command import SLCommand as SLCommand
+from SoftLayer.CLI import environment
 from SoftLayer import config
 from SoftLayer import consts
-from SoftLayer.CLI import environment
 
 
 def censor_password(value):
+    """Replaces a password with *s"""
     if value:
         value = '*' * len(value)
     return value
 
+
 @click.command(cls=SLCommand)
 @environment.pass_env
 def cli(env):
     """Logs you into the internal SoftLayer Network.
 
-    username: Set this in either the softlayer config, or SL_USER ENV variable 
+    username: Set this in either the softlayer config, or SL_USER ENV variable
     password: Set this in SL_PASSWORD env variable. You will be prompted for them otherwise.
     """
     config_settings = config.get_config(config_file=env.config_file)
@@ -36,18 +36,18 @@ def cli(env):
     if settings.get('access_token') and settings.get('userid'):
         client.authenticate_with_hash(settings.get('userid'), settings.get('access_token'))
         try:
-            employee = client.call('SoftLayer_User_Employee', 'getObject', id=settings.get('userid'), mask="mask[id,username]")
-            print(employee)
-            client.refresh_token(settings.get('userid'), settings.get('access_token'))
-            refresh = client.call('SoftLayer_User_Employee', 'refreshEncryptedToken', settings.get('access_token'), id=settings.get('userid'))
+            emp_id = settings.get('userid')
+            client.call('SoftLayer_User_Employee', 'getObject', id=emp_id, mask="mask[id,username]")
+            client.refresh_token(emp_id, settings.get('access_token'))
+            client.call('SoftLayer_User_Employee', 'refreshEncryptedToken', settings.get('access_token'), id=emp_id)
 
             config_settings['softlayer'] = settings
             config.write_config(config_settings, env.config_file)
             return
+        # pylint: disable=broad-exception-caught
         except Exception as ex:
             print("Error with Hash Authentication, try with password: {}".format(ex))
 
-
     url = settings.get('endpoint_url') or consts.API_EMPLOYEE_ENDPOINT
     click.echo("URL: {}".format(url))
     if username is None:
@@ -57,11 +57,10 @@ def cli(env):
         password = env.getpass("Password: ")
     click.echo("Password: {}".format(censor_password(password)))
     yubi = input("Yubi: ")
-
-    
     try:
-        result = client.authenticate_with_password(username, password, str(yubi))
+        result = client.authenticate_with_internal(username, password, str(yubi))
         print(result)
+    # pylint: disable=broad-exception-caught
     except Exception as e:
         click.echo("EXCEPTION: {}".format(e))
 

tests/api_tests.py

@@ -6,15 +6,15 @@
 """
 import io
 import os
-from unittest import mock as mock
 import requests
+from unittest import mock as mock
 
 import SoftLayer
 import SoftLayer.API
+from SoftLayer import auth as slauth
+from SoftLayer import exceptions
 from SoftLayer import testing
 from SoftLayer import transports
-from SoftLayer import exceptions
-from SoftLayer import auth as slauth
 
 
 class Initialization(testing.TestCase):
@@ -319,7 +319,6 @@ def test_authenticate_with_password(self, _call):
 
 class EmployeeClientTests(testing.TestCase):
 
-
     @staticmethod
     def setup_response(filename, status_code=200, total_items=1):
         basepath = os.path.dirname(__file__)
@@ -333,7 +332,6 @@ def setup_response(filename, status_code=200, total_items=1):
         response.status_code = status_code
         return response
 
-
     def set_up(self):
         self.client = SoftLayer.API.EmployeeClient(config_file='./tests/testconfig')
 
@@ -348,7 +346,7 @@ def test_auth_with_pass_failure(self, api_response):
     @mock.patch('SoftLayer.transports.xmlrpc.requests.Session.request')
     def test_auth_with_pass_success(self, api_response):
         api_response.return_value = self.setup_response('successLogin')
-        result = self.client.authenticate_with_password('testUser', 'testPassword', '123456')
+        result = self.client.authenticate_with_internal('testUser', 'testPassword', '123456')
         print(result)
         self.assertEqual(result['userId'], 1234)
         self.assertEqual(self.client.settings['softlayer']['userid'], '1234')
@@ -363,10 +361,10 @@ def test_auth_with_hash(self):
     @mock.patch('SoftLayer.transports.xmlrpc.requests.Session.request')
     def test_refresh_token(self, api_response):
         api_response.return_value = self.setup_response('refreshSuccess')
-        result = self.client.refresh_token(9999, 'qweasdzxcqweasdzxcqweasdzxc')
+        self.client.refresh_token(9999, 'qweasdzxcqweasdzxcqweasdzxc')
         self.assertEqual(self.client.auth.user_id, 9999)
         self.assertIn('REFRESHEDTOKENaaaa', self.client.auth.hash)
-    
+
     @mock.patch('SoftLayer.transports.xmlrpc.requests.Session.request')
     def test_expired_token_is_refreshed(self, api_response):
         api_response.side_effect = [
@@ -379,9 +377,9 @@ def test_expired_token_is_refreshed(self, api_response):
         result = self.client.call('SoftLayer_User_Employee', 'getObject', id=5555)
         self.assertIn('REFRESHEDTOKENaaaa', self.client.auth.hash)
         self.assertEqual('testUser', result['username'])
-        
+
     @mock.patch('SoftLayer.transports.xmlrpc.requests.Session.request')
-    def test_expired_token_is_really_expored(self, api_response):
+    def test_expired_token_is_really_expired(self, api_response):
         api_response.side_effect = [
             self.setup_response('expiredToken'),
             self.setup_response('expiredToken')
@@ -391,7 +389,6 @@ def test_expired_token_is_really_expored(self, api_response):
         exception = self.assertRaises(
             exceptions.SoftLayerAPIError,
             self.client.call, 'SoftLayer_User_Employee', 'getObject', id=5555)
-        self.assertEqual(None, self.client.auth)
         self.assertEqual(exception.faultCode, "SoftLayer_Exception_EncryptedToken_Expired")
 
     @mock.patch('SoftLayer.API.BaseClient.call')
@@ -408,4 +405,4 @@ def test_account_check(self, _call):
         _call.assert_has_calls([
             mock.call(self.client, 'SoftLayer_Account', 'getObject', id=1234),
             mock.call(self.client, 'SoftLayer_Account', 'getObject1', id=9999),
-        ])
+        ])