Making fixes to unit tests and some minor code refactoring for tests

This change make unit tests pass for Windows running Python 3.5
This change removed all callbacks from the test code to match the code
fixes recently pushed.
Updated gitignore to ignore files created by VS

Author: amishra-dev

.gitignore

@@ -45,3 +45,6 @@ src/build
 # Virtual Environments
 /env*
 
+# Visual Studio Files
+/.vs/*
+/tests/.vs/*

adal/self_signed_jwt.py

@@ -108,7 +108,11 @@ def _raise_on_invalid_thumbprint(self, thumbprint):
 
     @staticmethod
     def _sign_jwt(header, payload, certificate):
-        encoded_jwt = SelfSignedJwt._encode_jwt(payload, certificate, header)
+        try:
+            encoded_jwt = SelfSignedJwt._encode_jwt(payload, certificate, header)
+        except Exception as exp:
+            raise AdalError("Error:Invalid Certificate: Expected Start of Certificate to be '-----BEGIN RSA PRIVATE KEY-----'", exp)
+
         SelfSignedJwt._raise_on_invalid_jwt_signature(encoded_jwt)
         return encoded_jwt
 

adal/token_request.py

@@ -171,7 +171,7 @@ def _perform_wstrust_assertion_oauth_exchange(self, wstrust_response):
 
         oauth_parameters = {}
         grant_type = TokenRequest._get_saml_grant_type(wstrust_response)
-        assertion = b64encode(wstrust_response.token)
+        assertion = b64encode(wstrust_response.token.encode('utf-8'))
         oauth_parameters = self._create_oauth_parameters(grant_type)
         oauth_parameters[OAUTH2_PARAMETERS.ASSERTION] = assertion
 

adal/wstrust_response.py

@@ -151,7 +151,12 @@ def parse(self):
             raise AdalError("Received empty RSTR response body.")
 
         try:
-            self._dom = ET.fromstring(self._response)
+
+            try:
+                self._dom = ET.fromstring(self._response)
+            except Exception as exp:
+                raise AdalError('Failed to parse RSTR in to DOM', exp)
+
             self._parents = {c:p for p in self._dom.iter() for c in p}
             error_found = self._parse_error()
             if error_found:

tests/__init__.py

@@ -27,6 +27,7 @@
 
 import sys
 import os
+from adal import authentication_parameters
 
 if sys.version_info[:2] < (2, 7, ):
     try:

tests/config_sample.py

@@ -39,7 +39,7 @@
     #       the password created here.
 
     "username" : "[email protected]",
-    "password" : None,
+    "password" : "None",
     "tenant" : "XXXXXXXX.onmicrosoft.com",
 
     "authorityHostUrl" : "https://login.windows.net",

tests/test_authentication_parameters.py

@@ -243,17 +243,17 @@ def test_create_from_url_happy_string_url(self):
 
         httpretty.register_uri(httpretty.GET, uri=self.testUrl, body='foo', status=401, **{'www-authenticate':'Bearer authorization_uri="foobar,lkfj,;l,", fruitcake="f",resource="clark, &^()- q32,shark" , f="foo"'})
 
-        def _callback(err, parameters):
-            self.assertIsNone(err, "An error was raised during function {0}".format(err))
-            test_params = {
-                'authorizationUri' : 'foobar,lkfj,;l,',
-                'resource' : 'clark, &^()- q32,shark',
-            }
-            self.assertEqual(parameters.authorization_uri, test_params['authorizationUri'],
-                                'Parsed authorizationUri did not match expected value.: {0}'.format(parameters.authorization_uri))
-            self.assertEqual(parameters.resource, test_params['resource'],
-                                'Parsed resource  did not match expected value.: {0}'.format(parameters.resource))
-        adal.authentication_parameters.create_authentication_parameters_from_url(self.testUrl, _callback, None)
+        # maybe try-catch here to catch the error
+        parameters = adal.authentication_parameters.create_authentication_parameters_from_url(self.testUrl)
+
+        test_params = {
+            'authorizationUri' : 'foobar,lkfj,;l,',
+            'resource' : 'clark, &^()- q32,shark',
+        }
+        self.assertEqual(parameters.authorization_uri, test_params['authorizationUri'],
+                            'Parsed authorizationUri did not match expected value.: {0}'.format(parameters.authorization_uri))
+        self.assertEqual(parameters.resource, test_params['resource'],
+                            'Parsed resource  did not match expected value.: {0}'.format(parameters.resource))
 
         req = httpretty.last_request()
         util.match_standard_request_headers(req)
@@ -265,8 +265,8 @@ def test_create_from_url_happy_path_url_object(self):
 
         url_obj = urlparse(self.testUrl)
 
-        def _callback(err, parameters):
-            self.assertIsNone(err, "An error was raised during function {0}".format(err))
+        try:
+            parameters = adal.authentication_parameters.create_authentication_parameters_from_url(url_obj)
             test_params = {
                 'authorizationUri' : 'foobar,lkfj,;l,',
                 'resource' : 'clark, &^()- q32,shark',
@@ -276,45 +276,52 @@ def _callback(err, parameters):
             self.assertEqual(parameters.resource, test_params['resource'],
                                 'Parsed resource  did not match expected value.: {0}'.format(parameters.resource))
 
-        adal.authentication_parameters.create_authentication_parameters_from_url(url_obj, _callback)
+        except Exception as err:
+            self.assertIsNone(err, "An error was raised during function {0}".format(err))
 
         req = httpretty.last_request()
         util.match_standard_request_headers(req)
 
     def test_create_from_url_bad_object(self):
 
-        def _callback(err, resp):
-            self.assertIsNotNone(err, "Did not receive expected error.")
-
-        adal.authentication_parameters.create_authentication_parameters_from_url({}, _callback)
+        try:
+            parameters = adal.authentication_parameters.create_authentication_parameters_from_url({})
+        except Exception as exp:
+            self.assertIsNotNone(exp, "Did not receive expected error.")
+            pass
 
     def test_create_from_url_not_passed(self):
 
-        def _callback(err, resp):
-            self.assertIsNotNone(err, "Did not receive expected error.")
-
-        adal.authentication_parameters.create_authentication_parameters_from_url(None, _callback)
+        try:
+            parameters = adal.authentication_parameters.create_authentication_parameters_from_url(None)
+        except Exception as exp:
+            self.assertIsNotNone(exp, "Did not receive expected error.")
+            pass
 
     @httpretty.activate
     def test_create_from_url_no_header(self):
 
         httpretty.register_uri(httpretty.GET, uri=self.testUrl, body='foo', status=401)
 
-        def _callback(err, resp):
-            self.assertIsNotNone(err, "Did not receive expected error.")
+        receivedException = False
+        try:
+            adal.authentication_parameters.create_authentication_parameters_from_url(self.testUrl)
+        except Exception as err:
+            receivedException = True
             self.assertTrue(str(err).find('header') >= 0, 'Error did not include message about missing header')
-
-        adal.authentication_parameters.create_authentication_parameters_from_url(self.testUrl, _callback)
+            pass
+        finally:
+            self.assertTrue(receivedException)
 
         req = httpretty.last_request()
         util.match_standard_request_headers(req)
 
     def test_create_from_url_network_error(self):
 
-        def _callback(err, resp):
+        try:
+            adal.authentication_parameters.create_authentication_parameters_from_url('https://0.0.0.0/foobar')
+        except Exception as err:
             self.assertIsNotNone(err, "Did not receive expected error.")
 
-        adal.authentication_parameters.create_authentication_parameters_from_url('https://0.0.0.0/foobar', _callback)
-
 if __name__ == '__main__':
     unittest.main()

tests/test_authority.py

@@ -83,20 +83,21 @@ def test_success_dynamic_instance_discovery(self):
             self.nonHardCodedAuthorizeEndpoint
         )
 
-        responseOptions = { 'authority' : self.nonHardCodedAuthority}
+        responseOptions = { 'authority' : self.nonHardCodedAuthority }
         response = util.create_response(responseOptions)
         wireResponse = response['wireResponse']
 
         util.setup_expected_client_cred_token_request_response(200, wireResponse, self.nonHardCodedAuthority)
 
-        token_response = adal.acquire_token_with_client_credentials(
-            self.nonHardCodedAuthority, cp['clientId'], cp['clientSecret'], response['resource'])
+        context = adal.AuthenticationContext(self.nonHardCodedAuthority)
+        token_response = context.acquire_token_with_client_credentials(
+             response['resource'], cp['clientId'], cp['clientSecret'])
         self.assertTrue(
             util.is_match_token_response(response['cachedResponse'], token_response),
             'The response does not match what was expected.: ' + str(token_response)
         )
 
-    def performStaticInstanceDiscovery(self, authorityHost, callback):
+    def performStaticInstanceDiscovery(self, authorityHost):
         hardCodedAuthority = 'https://' + authorityHost + '/' + cp['tenant']
 
         responseOptions = {
@@ -106,8 +107,9 @@ def performStaticInstanceDiscovery(self, authorityHost, callback):
         wireResponse = response['wireResponse']
         tokenRequest = util.setup_expected_client_cred_token_request_response(200, wireResponse, hardCodedAuthority)
 
-        token_response = adal.acquire_token_with_client_credentials(
-            hardCodedAuthority, cp['clientId'], cp['clientSecret'], response['resource'])
+        context = adal.AuthenticationContext(hardCodedAuthority)
+        token_response = context.acquire_token_with_client_credentials(
+             response['resource'], cp['clientId'], cp['clientSecret'])
 
         self.assertTrue(
             util.is_match_token_response(response['cachedResponse'], token_response),
@@ -117,32 +119,31 @@ def performStaticInstanceDiscovery(self, authorityHost, callback):
 
     @httpretty.activate
     def test_success_static_instance_discovery(self):
-        def callback(err):
-            if err:
-                raise Exception(err)
 
-        self.performStaticInstanceDiscovery('login.microsoftonline.com', callback)
-        self.performStaticInstanceDiscovery('login.windows.net', callback)
-        self.performStaticInstanceDiscovery('login.chinacloudapi.cn', callback)
-        self.performStaticInstanceDiscovery('login.cloudgovapi.us', callback)
+        self.performStaticInstanceDiscovery('login.microsoftonline.com')
+        self.performStaticInstanceDiscovery('login.windows.net')
+        self.performStaticInstanceDiscovery('login.chinacloudapi.cn')
+        self.performStaticInstanceDiscovery('login.cloudgovapi.us')
 
 
     @httpretty.activate
     def test_http_error(self):
         util.setup_expected_instance_discovery_request(500, cp['authorityHosts']['global'], None, self.nonHardCodedAuthorizeEndpoint)
 
-        with self.assertRaisesRegexp(Exception, '500'):
-            token_response = adal.acquire_token_with_client_credentials(
-                self.nonHardCodedAuthority, cp['clientId'], cp['clientSecret'], cp['resource'])
+        with self.assertRaisesRegex(Exception, '500'):
+            context = adal.AuthenticationContext(self.nonHardCodedAuthority)
+            token_response = context.acquire_token_with_client_credentials(
+                 cp['resource'], cp['clientId'], cp['clientSecret'])
 
     @httpretty.activate
     def test_validation_error(self):
         returnDoc = { 'error' : 'invalid_instance', 'error_description' : 'the instance was invalid' }
         util.setup_expected_instance_discovery_request(400, cp['authorityHosts']['global'], returnDoc, self.nonHardCodedAuthorizeEndpoint)
 
-        with self.assertRaisesRegexp(Exception, 'instance was invalid'):
-            token_response = adal.acquire_token_with_client_credentials(
-                self.nonHardCodedAuthority, cp['clientId'], cp['clientSecret'], cp['resource'])
+        with self.assertRaisesRegex(Exception, 'instance was invalid'):
+            context = adal.AuthenticationContext(self.nonHardCodedAuthority)
+            token_response = context.acquire_token_with_client_credentials(
+                 cp['resource'], cp['clientId'], cp['clientSecret'])
 
     @httpretty.activate
     def test_validation_off(self):
@@ -159,8 +160,9 @@ def test_validation_off(self):
 
         util.setup_expected_client_cred_token_request_response(200, wireResponse, self.nonHardCodedAuthority)
 
-        token_response = adal.acquire_token_with_client_credentials(
-            self.nonHardCodedAuthority, cp['clientId'], cp['clientSecret'], response['resource'], validate_authority = False)
+        context = adal.AuthenticationContext(self.nonHardCodedAuthority)
+        token_response = context.acquire_token_with_client_credentials(
+             response['resource'], cp['clientId'], cp['clientSecret'])
         self.assertTrue(
             util.is_match_token_response(response['cachedResponse'], token_response),
             'The response does not match what was expected.: ' + str(token_response)
@@ -169,12 +171,12 @@ def test_validation_off(self):
 
     @httpretty.activate
     def test_bad_url_not_https(self):
-        with self.assertRaisesRegexp(ValueError, "The authority url must be an https endpoint\."):
+        with self.assertRaisesRegex(ValueError, "The authority url must be an https endpoint\."):
             context = AuthenticationContext('http://this.is.not.https.com/mytenant.com')
 
     @httpretty.activate
     def test_bad_url_has_query(self):
-        with self.assertRaisesRegexp(ValueError, "The authority url must not have a query string\."):
+        with self.assertRaisesRegex(ValueError, "The authority url must not have a query string\."):
             context = AuthenticationContext(cp['authorityTenant'] + '?this=should&not=be&here=foo')
 
     @httpretty.activate
@@ -190,13 +192,9 @@ def test_url_extra_path_elements(self):
         authority = Authority(authority_url, True)
         obj = util.create_empty_adal_object()
 
-        def callback(err):
-            if err:
-                self.assertFalse(err, 'Received unexpected error: ' + err.args[0])
-            req = httpretty.last_request()
-            util.match_standard_request_headers(req)
-
-        authority.validate(obj['call_context'], callback)
+        authority.validate(obj['call_context'])
+        req = httpretty.last_request()
+        util.match_standard_request_headers(req)
 
 if __name__ == '__main__':
     unittest.main()

tests/test_authorization_code.py

@@ -40,6 +40,7 @@
     import mock
 
 import adal
+from adal.authentication_context import AuthenticationContext
 from tests import util
 from tests.util import parameters as cp
 
@@ -83,7 +84,8 @@ def test_happy_path(self):
 
         self.setup_expected_auth_code_token_request_response(200, response['wireResponse'])
 
-        token_response = adal._acquire_token_with_authorization_code(cp['authUrl'], cp['clientId'], cp['clientSecret'], self.authorization_code, self.redirect_uri, response['resource'])
+        context = adal.AuthenticationContext(cp['authUrl'])
+        token_response = context.acquire_token_with_authorization_code(self.authorization_code, self.redirect_uri, response['resource'], cp['clientId'], cp['clientSecret'])
 
         self.assertTrue(util.is_match_token_response(response['decodedResponse'], token_response), 'The response did not match what was expected')