Python oauth2client.client.OAuth2Credentials() Examples

The following are 10 code examples of oauth2client.client.OAuth2Credentials(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module oauth2client.client , or try the search function .
Example #1
Source File: api_tests.py    From sndlatr with Apache License 2.0 6 votes vote down vote up
def test_refresh_failure(self):
        """
        Failure to refresh the access token should be treated as auth error.
        """

        def raise_invalid_grant(*args, **kwargs):
            raise AccessTokenRefreshError()

        with mock.patch('sndlatr.models.get_credentials') as getter, \
            self.notify_mock() as notify:
            cred = mock.MagicMock(spec=OAuth2Credentials)
            getter.return_value = cred
            cred.refresh.side_effect = raise_invalid_grant

            job = self.create_job(error_cnt=self.JOB_MAX_RETRIES)
            resp = self._post_send(job)
            self.assertEquals(resp.status_int, 200)
            notify.assert_called_with(job, 'auth') 
Example #2
Source File: test_file.py    From jarvis with GNU General Public License v2.0 6 votes vote down vote up
def test_pickle_and_json_interop(self):
        # Write a file with a pickled OAuth2Credentials.
        credentials = self._create_test_credentials()

        credentials_file = open(FILENAME, 'wb')
        pickle.dump(credentials, credentials_file)
        credentials_file.close()

        # Storage should be not be able to read that object, as the capability
        # to read and write credentials as pickled objects has been removed.
        storage = file_module.Storage(FILENAME)
        read_credentials = storage.get()
        self.assertIsNone(read_credentials)

        # Now write it back out and confirm it has been rewritten as JSON
        storage.put(credentials)
        with open(FILENAME) as credentials_file:
            data = json.load(credentials_file)

        self.assertEquals(data['access_token'], 'foo')
        self.assertEquals(data['_class'], 'OAuth2Credentials')
        self.assertEquals(data['_module'], client.OAuth2Credentials.__module__) 
Example #3
Source File: auth_test.py    From loaner with Apache License 2.0 5 votes vote down vote up
def test_cloud_credentials_constructor_no_local_file(
      self, expected_redirect_uri, run_web_server, mock_run_flow,
      mock_server_flow):
    """Test the creation of the CloudCredentials object with no local creds."""
    FLAGS.automatic_oauth = run_web_server
    mock_run_flow.return_value = oauth2_client.OAuth2Credentials(
        access_token='test_access_token',
        client_id=self._test_config.client_id,
        client_secret=self._test_config.client_secret,
        refresh_token='test_refresh_token',
        token_expiry=datetime.datetime(year=2018, month=1, day=1),
        token_uri='test_token_uri',
        user_agent=None,
        id_token='test_id_token',
        scopes=['test_scope1'])
    test_creds = auth.CloudCredentials(self._test_config, ['test_scope1'])
    self.assertEqual(self._test_config, test_creds._config)
    self.assertEqual('test_access_token', test_creds._credentials.token)
    self.assertEqual(
        'test_refresh_token', test_creds._credentials.refresh_token)
    self.assertEqual('test_id_token', test_creds._credentials.id_token)
    self.assertEqual('test_token_uri', test_creds._credentials.token_uri)
    self.assertEqual(
        self._test_config.client_id, test_creds._credentials.client_id)
    self.assertEqual(
        self._test_config.client_secret, test_creds._credentials.client_secret)
    self.assertEqual(['test_scope1'], test_creds._credentials.scopes)
    mock_server_flow.assert_called_once_with(
        client_id=self._test_config.client_id,
        client_secret=self._test_config.client_secret,
        scope=['test_scope1'],
        redirect_uri=expected_redirect_uri) 
Example #4
Source File: api_tests.py    From sndlatr with Apache License 2.0 5 votes vote down vote up
def build_credentials():
    return OAuth2Credentials('x', 'y', 'z', 'a', 'b', 'c', 'd',
                             id_token={'sub': '12345',
                                       'email': 'test@example.com'}) 
Example #5
Source File: utils.py    From df2gspread with GNU General Public License v3.0 5 votes vote down vote up
def _is_valid_credentials(credentials):
    return isinstance(credentials, client.OAuth2Credentials) 
Example #6
Source File: test_auth.py    From getting-started-python with Apache License 2.0 5 votes vote down vote up
def client_with_credentials(app):
    """This fixture provides a Flask app test client that has a session
    pre-configured with use credentials."""
    credentials = OAuth2Credentials(
        'access_token',
        'client_id',
        'client_secret',
        'refresh_token',
        '3600',
        None,
        'Test',
        id_token={'sub': '123', 'email': 'user@example.com'},
        scopes=('email', 'profile'))

    @contextlib.contextmanager
    def inner():
        with app.test_client() as client:
            with client.session_transaction() as session:
                session['profile'] = {
                    'email': 'abc@example.com',
                    'name': 'Test User'
                }
                session['google_oauth2_credentials'] = credentials.to_json()
            yield client

    return inner


# Mark all test cases in this class as flaky, so that if errors occur they
# can be retried. This is useful when databases are temporarily unavailable. 
Example #7
Source File: test_file.py    From jarvis with GNU General Public License v2.0 5 votes vote down vote up
def _create_test_credentials(self, client_id='some_client_id',
                                 expiration=None):
        access_token = 'foo'
        client_secret = 'cOuDdkfjxxnv+'
        refresh_token = '1/0/a.df219fjls0'
        token_expiry = expiration or datetime.datetime.utcnow()
        token_uri = 'https://www.google.com/accounts/o8/oauth2/token'
        user_agent = 'refresh_checker/1.0'

        credentials = client.OAuth2Credentials(
            access_token, client_id, client_secret,
            refresh_token, token_expiry, token_uri,
            user_agent)
        return credentials 
Example #8
Source File: appengine_rpc_httplib2.py    From browserscope with Apache License 2.0 4 votes vote down vote up
def __init__(self, host, refresh_token, user_agent, source,
               host_override=None, extra_headers=None, save_cookies=False,
               auth_tries=None, account_type=None, debug_data=True, secure=True,
               ignore_certs=False, rpc_tries=3):
    """Creates a new HttpRpcServerOauth2.

    Args:
      host: The host to send requests to.
      refresh_token: A string refresh token to use, or None to guide the user
        through the auth flow. (Replaces auth_function on parent class.)
      user_agent: The user-agent string to send to the server. Specify None to
        omit the user-agent header.
      source: Tuple, (client_id, client_secret, scope), for oauth credentials.
      host_override: The host header to send to the server (defaults to host).
      extra_headers: A dict of extra headers to append to every request. Values
        supplied here will override other default headers that are supplied.
      save_cookies: If the refresh token should be saved.
      auth_tries: The number of times to attempt auth_function before failing.
      account_type: Ignored.
      debug_data: Whether debugging output should include data contents.
      secure: If the requests sent using Send should be sent over HTTPS.
      ignore_certs: If the certificate mismatches should be ignored.
      rpc_tries: The number of rpc retries upon http server error (i.e.
        Response code >= 500 and < 600) before failing.
    """
    super(HttpRpcServerOauth2, self).__init__(
        host, None, user_agent, None, host_override=host_override,
        extra_headers=extra_headers, auth_tries=auth_tries,
        debug_data=debug_data, secure=secure, ignore_certs=ignore_certs,
        rpc_tries=rpc_tries)

    if not isinstance(source, tuple) or len(source) not in (3, 4):
      raise TypeError('Source must be tuple (client_id, client_secret, scope).')

    self.client_id = source[0]
    self.client_secret = source[1]
    self.scope = source[2]
    oauth2_credential_file = (len(source) > 3 and source[3]
                              or '~/.appcfg_oauth2_tokens')

    if save_cookies:
      self.storage = oauth2client_file.Storage(
          os.path.expanduser(oauth2_credential_file))
    else:
      self.storage = NoStorage()

    self.refresh_token = refresh_token
    if refresh_token:
      self.credentials = client.OAuth2Credentials(
          None,
          self.client_id,
          self.client_secret,
          refresh_token,
          None,
          ('https://%s/o/oauth2/token' %
           os.getenv('APPENGINE_AUTH_SERVER', 'accounts.google.com')),
          self.user_agent)
    else:
      self.credentials = self.storage.get() 
Example #9
Source File: utils.py    From df2gspread with GNU General Public License v3.0 4 votes vote down vote up
def get_credentials(credentials=None, client_secret_file=CLIENT_SECRET_FILE, refresh_token=None):
    """Consistently returns valid credentials object.

    See Also:
        https://developers.google.com/drive/web/quickstart/python

    Args:
        client_secret_file (str): path to client secrets file, defaults to .gdrive_private
        refresh_token (str): path to a user provided refresh token that is already
            pre-authenticated
        credentials (`~oauth2client.client.OAuth2Credentials`, optional): handle direct
            input of credentials, which will check credentials for valid type and
            return them

    Returns:
        `~oauth2client.client.OAuth2Credentials`: google credentials object

    """

    # if the utility was provided credentials just return those
    if credentials:
        if _is_valid_credentials(credentials):
            # auth for gspread
            return credentials
        else:
            print("Invalid credentials supplied. Will generate from default token.")

    token = refresh_token or DEFAULT_TOKEN
    dir_name = os.path.dirname(DEFAULT_TOKEN)
    try:
        os.makedirs(dir_name)
    except OSError:
        if not os.path.isdir(dir_name):
            raise
    store = file.Storage(token)
    credentials = store.get()

    try:
        import argparse
        flags = argparse.ArgumentParser(
            parents=[tools.argparser]).parse_known_args()[0]
    except ImportError:
        flags = None
        logr.error(
            'Unable to parse oauth2client args; `pip install argparse`')

    if not credentials or credentials.invalid:

        flow = client.flow_from_clientsecrets(
            client_secret_file, SCOPES)
        flow.redirect_uri = client.OOB_CALLBACK_URN
        if flags:
            credentials = tools.run_flow(flow, store, flags)
        else:  # Needed only for compatability with Python 2.6
            credentials = tools.run(flow, store)
        logr.info('Storing credentials to ' + DEFAULT_TOKEN)

    return credentials 
Example #10
Source File: utils.py    From df2gspread with GNU General Public License v3.0 4 votes vote down vote up
def create_service_credentials(private_key_file=None, client_email=None,
                               client_secret_file=CLIENT_SECRET_FILE):
    """Create credentials from service account information.

    See Also:
        https://developers.google.com/api-client-library/python/auth/service-accounts

    Args:
        client_secret_file (str): path to json file with just the client_email when
            providing the `private_key_file` separately, or this file can have both the
            `client_email` and `private_key` contained in it. Defaults to .gdrive_private
        client_email (str): service email account
        private_key_file (str): path to the p12 private key, defaults to same name of file
            used for regular authentication

    Returns:
        `~oauth2client.client.OAuth2Credentials`: google credentials object

    """
    if private_key_file is not None:
        with open(os.path.expanduser(private_key_file)) as f:
            private_key = f.read()
    else:
        private_key = None

    if client_email is None:
        with open(os.path.expanduser(client_secret_file)) as client_file:
            client_data = json.load(client_file)

            if 'installed' in client_data:

                # handle regular json format where key is separate
                client_email = client_data['installed']['client_id']
                if private_key is None:
                    raise RuntimeError('You must have the private key file \
                                       with the regular json file. Try creating a new \
                                       public/private key pair and downloading as json.')
            else:
                # handle newer case where json file has everything in it
                client_email = client_data['client_email']
                private_key = client_data['private_key']

    if client_email is None or private_key is None:
        raise RuntimeError(
            'Client email and/or private key not provided by inputs.')

    credentials = client.SignedJwtAssertionCredentials(
        client_email, private_key, SCOPES)

    return credentials