googleauth 1.14.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e2eef22c1062f2fd2216760e90a1af9ece1b99838bccea486a7b4ce43be9734
-  data.tar.gz: 1e60ef4856de1e4f7a3d423f3953e5e39f86c7002216ad2d98ee46ec88aaaf25
+  metadata.gz: 34a8ff0141f7866d8f253bea4adbdd406c8aab873c7f18be6ac78ee981e16a39
+  data.tar.gz: 1191ce29114f13eb0d855ef46502015eb309cf694bd053171614b15d571e15f7
 SHA512:
-  metadata.gz: d5a87f962d04eb59c9ae083a4d3c46fd54ef4d4c53f0571b3952f6d1a9d30e3af89fb2c50e04b118e301097850c9985c713968dc29c62c5d388d0d8a4c3d306d
-  data.tar.gz: fae67434766ed2d4bb67e2c7ba2784a9397843110c28d96368d368b1dd30229a1ea83c5ee05e70a712446781e67ca84149fbaa72dd4239eb349d6943ff42b9b3
+  metadata.gz: 9286311e4de659c8820cdbdfb4ae48f1a3b0c519c66208a3c3f56a3a1079597b10306d6ab8aef05687df347262f26c75af63c4cbeac7570162829d926edf0317
+  data.tar.gz: 43954778b73cf95537a29a2317abe5b22eebfc3336e560657ec580542df9a7e9f42513968d27fc2b13621b0da0aa8fb8510ef59c9170bad611b0bd5b86f16888

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Release History
 
+### 1.15.0 (2025-08-25)
+
+#### Features
+
+* add typed errors to authentication library ([#533](https://github.com/googleapis/google-auth-library-ruby/issues/533)) 
+* Support for JWT 3.x ([#542](https://github.com/googleapis/google-auth-library-ruby/issues/542)) 
+#### Bug Fixes
+
+* fix incorrect error and apply some code complexity refactoring ([#529](https://github.com/googleapis/google-auth-library-ruby/issues/529)) 
+* support Pathname for cred loading ([#537](https://github.com/googleapis/google-auth-library-ruby/issues/537)) 
+#### Documentation
+
+* add summary documentation on credentials types and improve YARD comments 
+* add summary documentation on credentials types and improve YARD comments ([#530](https://github.com/googleapis/google-auth-library-ruby/issues/530)) 
+
 ### 1.14.0 (2025-03-14)
 
 #### Features

data/Credentials.md

@@ -0,0 +1,106 @@
+# Introduction
+
+The closest thing to a base credentials class is the `BaseClient` module. 
+It includes functionality common to most credentials, such as applying authentication tokens to request headers, managing token expiration and refresh, handling logging, and providing updater procs for API clients.
+
+Many credentials classes inherit from `Signet::OAuth2::Client` (`lib/googleauth/signet.rb`) class which provides OAuth-based authentication.
+The `Signet::OAuth2::Client` includes the `BaseClient` functionality.
+
+Most credential types either inherit from `Signet::OAuth2::Client` or include the `BaseClient` module directly.
+
+Notably, `Google::Auth::Credentials` (`lib/googleauth/credentials.rb`) is not a base type or a credentials type per se. It is a wrapper for other credential classes
+that exposes common initialization functionality, such as creating credentials from environment variables, default paths, or application defaults. It is used and subclassed by Google's API client libraries.
+
+# List of credentials types
+
+## Simple Authentication (non-OAuth)
+
+**Google::Auth::APIKeyCredentials** - `lib/googleauth/api_key.rb`
+   - Includes `Google::Auth::BaseClient` module
+   - Implements Google API Key authentication
+   - API Keys are text strings that don't have an associated JSON file
+   - API Keys provide project information but don't reference an IAM principal
+   - They do not expire and cannot be refreshed
+   - Can be loaded from the `GOOGLE_API_KEY` environment variable
+
+2. **Google::Auth::BearerTokenCredentials** - `lib/googleauth/bearer_token.rb`
+   - Includes `Google::Auth::BaseClient` module
+   - Implements Bearer Token authentication
+   - Bearer tokens are strings representing an authorization grant
+   - Can be OAuth2 tokens, JWTs, ID tokens, or any token sent as a `Bearer` in an `Authorization` header
+   - Used when the end-user is managing the token separately (e.g., with another service)
+   - Token lifetime tracking and refresh are outside this class's scope
+   - No JSON representation for this type of credentials
+
+## GCP-Specialized authentication
+
+3. **Google::Auth::GCECredentials < Signet::OAuth2::Client** - `lib/googleauth/compute_engine.rb`
+   - For obtaining authentication tokens from GCE metadata server
+   - Used automatically when code is running on Google Compute Engine
+   - Fetches tokens from the metadata server with no additional configuration needed
+
+4. **Google::Auth::IAMCredentials < Signet::OAuth2::Client** - `lib/googleauth/iam.rb`
+   - For IAM-based authentication (e.g. service-to-service)
+   - Implements authentication-as-a-service for systems already authenticated
+   - Exchanges existing credentials for a short-lived access token
+
+## Service Account Authentication
+
+5. **Google::Auth::ServiceAccountCredentials < Signet::OAuth2::Client** - `lib/googleauth/service_account.rb`
+   - Authenticates requests using Service Account credentials via an OAuth access token
+   - Created from JSON key file downloaded from Google Cloud Console
+   - Supports both OAuth access tokens and self-signed JWT authentication
+   - Can specify scopes for access token requests
+
+6. **Google::Auth::ServiceAccountJwtHeaderCredentials** - `lib/googleauth/service_account_jwt_header.rb`
+   - Authenticates using Service Account credentials with JWT headers
+   - Typically used via `ServiceAccountCredentials` and not by itself
+   - Creates JWT directly for making authenticated calls
+   - Does not require a round trip to the authorization server
+   - Doesn't support OAuth scopes - uses audience (target API) instead
+
+7. **Google::Auth::ImpersonatedServiceAccountCredentials < Signet::OAuth2::Client** - `lib/googleauth/impersonated_service_account.rb`
+   - For service account impersonation
+   - Allows a GCP principal identified by a set of source credentials to impersonate a service account
+   - Useful for delegation of authority and managing permissions across service accounts
+   - Source credentials must have the Service Account Token Creator role on the target
+
+## User Authentication
+
+8. **Google::Auth::UserRefreshCredentials < Signet::OAuth2::Client** - `lib/googleauth/user_refresh.rb`
+   - For user refresh token authentication (from 3-legged OAuth flow)
+   - Authenticates on behalf of a user who has authorized the application
+   - Handles token refresh when original access token expires
+   - Typically obtained through web or installed application flow
+
+`Google::Auth::UserAuthorizer` (`lib/googleauth/user_authorizer.rb`) and `Google::Auth::WebUserAuthorizer` (`lib/googleauth/web_user_authorizer.rb`)
+ are used to facilitate user authentication. The `UserAuthorizer` handles interactive 3-Legged-OAuth2 (3LO) user consent authorization for command-line applications.
+ The `WebUserAuthorizer` is a variation of UserAuthorizer adapted for Rack-based web applications that manages OAuth state and provides callback handling.
+
+## External Account Authentication
+  `Google::Auth::ExternalAccount::Credentials` (`lib/googleauth/external_account.rb`) is not a credentials type, it is a module
+  that procides an entry point for External Account credentials. It also serves as a factory that creates appropriate credential
+  types based on credential source (similar to `Google::Auth::get_application_default`).
+  It is included in all External Account credentials types, and it itself includes `Google::Auth::BaseClient` module so all External
+  Account credentials types include `Google::Auth::BaseClient`.
+
+9. **Google::Auth::ExternalAccount::AwsCredentials** - `lib/googleauth/external_account/aws_credentials.rb`
+     - Includes `Google::Auth::BaseClient` module
+     - Includes `ExternalAccount::BaseCredentials` module
+     - Uses AWS credentials to authenticate to Google Cloud
+     - Exchanges temporary AWS credentials for Google access tokens
+     - Used for workloads running on AWS that need to access Google Cloud
+
+10. **Google::Auth::ExternalAccount::IdentityPoolCredentials** - `lib/googleauth/external_account/identity_pool_credentials.rb`
+     - Includes `Google::Auth::BaseClient` module
+     - Includes `ExternalAccount::BaseCredentials` module
+     - Authenticates using external identity pool
+     - Exchanges external identity tokens for Google access tokens
+     - Supports file-based and URL-based credential sources
+
+11. **Google::Auth::ExternalAccount::PluggableCredentials** - `lib/googleauth/external_account/pluggable_credentials.rb`
+     - Includes `Google::Auth::BaseClient` module
+     - Includes `ExternalAccount::BaseCredentials` module
+     - Supports executable-based credential sources
+     - Executes external programs to retrieve credentials
+     - Allows for custom authentication mechanisms via external executables

data/Errors.md

@@ -0,0 +1,152 @@
+# Error Handling in Google Auth Library for Ruby
+
+## Overview
+
+The Google Auth Library for Ruby provides a structured approach to error handling. This document explains the error hierarchy, how to access detailed error information, and provides examples of handling errors effectively.
+
+## Error Hierarchy
+
+The Google Auth Library has two main error hierarchies: the core authentication errors and the specialized ID token flow errors.
+
+### Core Authentication Errors
+
+These errors are used throughout the main library for general authentication and credential operations:
+
+```
+Google::Auth::Error (module)
+  ├── Google::Auth::InitializationError (class)
+  └── Google::Auth::DetailedError (module)
+      ├── Google::Auth::CredentialsError (class)
+      ├── Google::Auth::AuthorizationError (class)
+      ├── Google::Auth::UnexpectedStatusError (class)
+      └── Google::Auth::ParseError (class)
+```
+
+### ID Token Errors
+
+These specialized errors are used specifically for ID token flow. They also include the `Google::Auth::Error` module, allowing them to be caught with the same error handling as the core authentication errors:
+
+```
+Google::Auth::Error (module)
+  ├── Google::Auth::IDTokens::KeySourceError (class)
+  └── Google::Auth::IDTokens::VerificationError (class)
+      ├── ExpiredTokenError (class)
+      ├── SignatureError (class)
+      ├── IssuerMismatchError (class)
+      ├── AudienceMismatchError (class)
+      └── AuthorizedPartyMismatchError (class)
+```
+
+### Error Module Types
+
+- **`Google::Auth::Error`**: Base module that all Google Auth errors include. Use this to catch any error from the library.
+
+- **`Google::Auth::DetailedError`**: Extends `Error` to include detailed information about the credential that caused the error, including the credential type and principal.
+
+## Core Authentication Error Classes
+
+- **`InitializationError`**: Raised during credential initialization when required parameters are missing or invalid.
+
+- **`CredentialsError`**: Generic error raised during authentication flows.
+
+- **`AuthorizationError`**: Raised when a remote server refuses to authorize the client. Inherits from `Signet::AuthorizationError`. Is being raised where `Signet::AuthorizationError` was raised previously.
+
+- **`UnexpectedStatusError`**: Raised when a server returns an unexpected HTTP status code. Inherits from `Signet::UnexpectedStatusError`. Is being raised where `Signet::UnexpectedStatusError` was raised previously.
+
+- **`ParseError`**: Raised when the client fails to parse a value from a response. Inherits from `Signet::ParseError`. Is being raised where `Signet::ParseError` was raised previously.
+
+## Detailed Error Information
+
+Errors that include the `DetailedError` module provide additional context about what went wrong:
+
+- **`credential_type_name`**: The class name of the credential that raised the error (e.g., `"Google::Auth::ServiceAccountCredentials"`)
+
+- **`principal`**: The identity associated with the credentials (e.g., an email address for service accounts, `:api_key` for API key credentials)
+
+### Example: Catching and Handling Core Errors
+
+```ruby
+begin
+  credentials = Google::Auth::ServiceAccountCredentials.make_creds(
+    json_key_io: File.open("your-key.json")
+  )
+  # Use credentials...
+rescue Google::Auth::InitializationError => e
+  puts "Failed to initialize credentials: #{e.message}"
+  # e.g., Missing required fields in the service account key file
+rescue Google::Auth::DetailedError => e
+  puts "Authorization failed: #{e.message}"
+  puts "Credential type: #{e.credential_type_name}"
+  puts "Principal: #{e.principal}"
+  # e.g., Invalid or revoked service account
+rescue Google::Auth::Error => e
+  puts "Unknown Google Auth error: #{e.message}"
+end
+```
+
+## Backwards compatibility
+
+Some classes in the Google Auth Library raise standard Ruby `ArgumentError` and `TypeError`. These errors are preserved for backward compatibility, however the new code will raise `Google::Auth::InitializationError` instead.
+
+## ID Token Verification
+
+The Google Auth Library includes functionality for verifying ID tokens through the `Google::Auth::IDTokens` namespace. These operations have their own specialized error classes that also include the `Google::Auth::Error` module, allowing them to be caught with the same error handling as other errors in the library.
+
+### ID Token Error Classes
+
+- **`KeySourceError`**: Raised when the library fails to obtain the keys needed to verify a token, typically from a JWKS (JSON Web Key Set) endpoint.
+
+- **`VerificationError`**: Base class for all errors related to token verification failures.
+
+- **`ExpiredTokenError`**: Raised when a token has expired according to its expiration time claim (`exp`).
+
+- **`SignatureError`**: Raised when a token's signature cannot be verified, indicating it might be tampered with or corrupted.
+
+- **`IssuerMismatchError`**: Raised when a token's issuer (`iss` claim) doesn't match the expected issuer.
+
+- **`AudienceMismatchError`**: Raised when a token's audience (`aud` claim) doesn't match the expected audience.
+
+- **`AuthorizedPartyMismatchError`**: Raised when a token's authorized party (`azp` claim) doesn't match the expected client ID.
+
+### Example: Handling ID Token Verification Errors
+
+```ruby
+require "googleauth/id_tokens"
+
+begin
+  # Verify the provided ID token
+  payload = Google::Auth::IDTokens.verify_oidc(
+    id_token,
+    audience: "expected-audience-12345.apps.googleusercontent.com"
+  )
+  
+  # Use the verified token payload
+  user_email = payload["email"]
+  
+rescue Google::Auth::IDTokens::ExpiredTokenError => e
+  puts "The token has expired. Please obtain a new one."
+
+rescue Google::Auth::IDTokens::SignatureError => e
+  puts "Invalid token signature."
+
+rescue Google::Auth::IDTokens::IssuerMismatchError => e
+  puts "Invalid token issuer."
+
+rescue Google::Auth::IDTokens::AudienceMismatchError => e
+  puts "This token is not intended for this application (invalid audience)."
+  
+rescue Google::Auth::IDTokens::AuthorizedPartyMismatchError => e
+  puts "Invalid token authorized party."
+
+rescue Google::Auth::IDTokens::VerificationError => e
+  puts "Token verification failed: #{e.message}"
+  # Generic verification error handling
+  
+rescue Google::Auth::IDTokens::KeySourceError => e
+  puts "Unable to retrieve verification keys: #{e.message}"
+  
+rescue Google::Auth::Error => e
+  puts "Unknown Google Auth error: #{e.message}"
+  # This will catch any Google Auth error
+end
+```

data/lib/googleauth/api_key.rb

@@ -85,6 +85,7 @@ module Google
       # @option options [String] :universe_domain
       #   The universe domain of the universe this API key
       #   belongs to (defaults to googleapis.com)
+      # @raise [ArgumentError] If the API key is nil or empty
       def initialize options = {}
         raise ArgumentError, "API key must be provided" if options[:api_key].nil? || options[:api_key].empty?
         @api_key = options[:api_key]
@@ -139,6 +140,14 @@ module Google
         a_hash
       end
 
+      # For credentials that are initialized with a token without a principal,
+      # the type of that token should be returned as a principal instead
+      # @private
+      # @return [Symbol] the token type in lieu of the principal
+      def principal
+        token_type
+      end
+
       protected
 
       # The token type should be :api_key

data/lib/googleauth/application_default.rb

@@ -14,6 +14,7 @@
 
 require "googleauth/compute_engine"
 require "googleauth/default_credentials"
+require "googleauth/errors"
 
 module Google
   # Module Auth provides classes that provide Google-specific authorization
@@ -50,12 +51,13 @@ module Google
     #       connection to use for token refresh requests.
     #     * `:connection` The connection to use to determine whether GCE
     #       metadata credentials are available.
+    # @raise [Google::Auth::InitializationError] If the credentials cannot be found
     def get_application_default scope = nil, options = {}
       creds = DefaultCredentials.from_env(scope, options) ||
               DefaultCredentials.from_well_known_path(scope, options) ||
               DefaultCredentials.from_system_default_path(scope, options)
       return creds unless creds.nil?
-      raise NOT_FOUND_ERROR unless GCECredentials.on_gce? options
+      raise InitializationError, NOT_FOUND_ERROR unless GCECredentials.on_gce? options
       GCECredentials.new options.merge(scope: scope)
     end
   end

data/lib/googleauth/base_client.rb

@@ -78,6 +78,11 @@ module Google
       # The logger used to log operations on this client, such as token refresh.
       attr_accessor :logger
 
+      # @private
+      def principal
+        raise NoMethodError, "principal not implemented"
+      end
+
       private
 
       def token_type

data/lib/googleauth/bearer_token.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require "googleauth/base_client"
+require "googleauth/errors"
 
 module Google
   module Auth
@@ -80,6 +81,7 @@ module Google
       #   If `expires_at` is `nil`, it is treated as "token never expires".
       # @option options [String] :universe_domain The universe domain of the universe
       #   this token is for (defaults to googleapis.com)
+      # @raise [ArgumentError] If the bearer token is nil or empty
       def initialize options = {}
         raise ArgumentError, "Bearer token must be provided" if options[:token].nil? || options[:token].empty?
         @token = options[:token]
@@ -119,6 +121,14 @@ module Google
         )
       end
 
+      # For credentials that are initialized with a token without a principal,
+      # the type of that token should be returned as a principal instead
+      # @private
+      # @return [Symbol] the token type in lieu of the principal
+      def principal
+        token_type
+      end
+
       protected
 
       ##
@@ -129,10 +139,14 @@ module Google
       #
       # @param [Hash] _options Options for fetching a new token (not used).
       # @return [nil] Always returns nil.
-      # @raise [StandardError] If the token is expired.
+      # @raise [Google::Auth::CredentialsError] If the token is expired.
       def fetch_access_token! _options = {}
         if @expires_at && Time.now >= @expires_at
-          raise "Bearer token has expired."
+          raise CredentialsError.with_details(
+            "Bearer token has expired.",
+            credential_type_name: self.class.name,
+            principal: principal
+          )
         end
 
         nil

data/lib/googleauth/client_id.rb

@@ -14,6 +14,7 @@
 
 require "multi_json"
 require "googleauth/credentials_loader"
+require "googleauth/errors"
 
 module Google
   module Auth
@@ -62,10 +63,11 @@ module Google
       # @note Direct instantiation is discouraged to avoid embedding IDs
       #       and secrets in source. See {#from_file} to load from
       #       `client_secrets.json` files.
+      # @raise [Google::Auth::InitializationError] If id or secret is nil
       #
       def initialize id, secret
-        raise "Client id can not be nil" if id.nil?
-        raise "Client secret can not be nil" if secret.nil?
+        raise InitializationError, "Client id can not be nil" if id.nil?
+        raise InitializationError, "Client secret can not be nil" if secret.nil?
         @id = id
         @secret = secret
       end
@@ -77,9 +79,10 @@ module Google
       # @param [String, File] file
       #  Path of file to read from
       # @return [Google::Auth::ClientID]
+      # @raise [Google::Auth::InitializationError] If file is nil
       #
       def self.from_file file
-        raise "File can not be nil." if file.nil?
+        raise InitializationError, "File can not be nil." if file.nil?
         File.open file.to_s do |f|
           json = f.read
           config = MultiJson.load json
@@ -94,11 +97,12 @@ module Google
       # @param [hash] config
       #  Parsed contents of the JSON file
       # @return [Google::Auth::ClientID]
+      # @raise [Google::Auth::InitializationError] If config is nil or missing required elements
       #
       def self.from_hash config
-        raise "Hash can not be nil." if config.nil?
+        raise InitializationError, "Hash can not be nil." if config.nil?
         raw_detail = config[INSTALLED_APP] || config[WEB_APP]
-        raise MISSING_TOP_LEVEL_ELEMENT_ERROR if raw_detail.nil?
+        raise InitializationError, MISSING_TOP_LEVEL_ELEMENT_ERROR if raw_detail.nil?
         ClientId.new raw_detail[CLIENT_ID], raw_detail[CLIENT_SECRET]
       end
     end

data/lib/googleauth/compute_engine.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require "google-cloud-env"
+require "googleauth/errors"
 require "googleauth/signet"
 
 module Google
@@ -126,31 +127,25 @@ module Google
 
       # Overrides the super class method to change how access tokens are
       # fetched.
+      #
+      # @param [Hash] _options Options for token fetch (not used)
+      # @return [Hash] The token data hash
+      # @raise [Google::Auth::UnexpectedStatusError] On unexpected HTTP status codes
+      # @raise [Google::Auth::AuthorizationError] If metadata server is unavailable or returns error
       def fetch_access_token _options = {}
-        query, entry =
-          if token_type == :id_token
-            [{ "audience" => target_audience, "format" => "full" }, "service-accounts/default/identity"]
-          else
-            [{}, "service-accounts/default/token"]
-          end
-        query[:scopes] = Array(scope).join "," if scope
+        query, entry = build_metadata_request_params
         begin
           log_fetch_query
           resp = Google::Cloud.env.lookup_metadata_response "instance", entry, query: query
           log_fetch_resp resp
-          case resp.status
-          when 200
-            build_token_hash resp.body, resp.headers["content-type"], resp.retrieval_monotonic_time
-          when 403, 500
-            raise Signet::UnexpectedStatusError, "Unexpected error code #{resp.status} #{UNEXPECTED_ERROR_SUFFIX}"
-          when 404
-            raise Signet::AuthorizationError, NO_METADATA_SERVER_ERROR
-          else
-            raise Signet::AuthorizationError, "Unexpected error code #{resp.status} #{UNEXPECTED_ERROR_SUFFIX}"
-          end
+          handle_metadata_response resp
         rescue Google::Cloud::Env::MetadataServerNotResponding => e
           log_fetch_err e
-          raise Signet::AuthorizationError, e.message
+          raise AuthorizationError.with_details(
+            e.message,
+            credential_type_name: self.class.name,
+            principal: principal
+          )
         end
       end
 
@@ -175,8 +170,47 @@ module Google
         self
       end
 
+      # Returns the principal identifier for GCE credentials
+      # @private
+      # @return [Symbol] :gce to represent Google Compute Engine identity
+      def principal
+        :gce_metadata
+      end
+
       private
 
+      # @private
+      # Builds query parameters and endpoint for metadata request
+      # @return [Array] The query parameters and endpoint path
+      def build_metadata_request_params
+        query, entry =
+          if token_type == :id_token
+            [{ "audience" => target_audience, "format" => "full" }, "service-accounts/default/identity"]
+          else
+            [{}, "service-accounts/default/token"]
+          end
+        query[:scopes] = Array(scope).join "," if scope
+        [query, entry]
+      end
+
+      # @private
+      # Handles the response from the metadata server
+      # @param [Google::Cloud::Env::MetadataResponse] resp The metadata server response
+      # @return [Hash] The token hash on success
+      # @raise [Google::Auth::UnexpectedStatusError, Google::Auth::AuthorizationError] On error
+      def handle_metadata_response resp
+        case resp.status
+        when 200
+          build_token_hash resp.body, resp.headers["content-type"], resp.retrieval_monotonic_time
+        when 403, 500
+          raise Signet::UnexpectedStatusError, "Unexpected error code #{resp.status} #{UNEXPECTED_ERROR_SUFFIX}"
+        when 404
+          raise Signet::AuthorizationError, NO_METADATA_SERVER_ERROR
+        else
+          raise Signet::AuthorizationError, "Unexpected error code #{resp.status} #{UNEXPECTED_ERROR_SUFFIX}"
+        end
+      end
+
       def log_fetch_query
         if token_type == :id_token
           logger&.info do
@@ -213,6 +247,18 @@ module Google
         end
       end
 
+      # Constructs a token hash from the metadata server response
+      #
+      # @private
+      # @param [String] body The response body from the metadata server
+      # @param [String] content_type The content type of the response
+      # @param [Float] retrieval_time The monotonic time when the response was retrieved
+      #
+      # @return [Hash] A hash containing:
+      #   - access_token/id_token: The actual token depending on what was requested
+      #   - token_type: The type of token (usually "Bearer")
+      #   - expires_in: Seconds until token expiration (adjusted for freshness)
+      #   - universe_domain: The universe domain for the token (if not overridden)
       def build_token_hash body, content_type, retrieval_time
         hash =
           if ["text/html", "application/text"].include? content_type

data/lib/googleauth/credentials.rb

@@ -14,9 +14,11 @@
 
 require "forwardable"
 require "json"
+require "pathname"
 require "signet/oauth_2/client"
 
 require "googleauth/credentials_loader"
+require "googleauth/errors"
 
 module Google
   module Auth
@@ -357,12 +359,13 @@ module Google
       # Creates a new Credentials instance with the provided auth credentials, and with the default
       # values configured on the class.
       #
-      # @param [String, Hash, Signet::OAuth2::Client] source_creds
+      # @param [String, Pathname, Hash, Google::Auth::BaseClient] source_creds
       #   The source of credentials. It can be provided as one of the following:
       #
-      #   * The path to a JSON keyfile (as a `String`)
+      #   * The path to a JSON keyfile (as a `String` or a `Pathname`)
       #   * The contents of a JSON keyfile (as a `Hash`)
-      #   * A `Signet::OAuth2::Client` credentials object
+      #   * A `Google::Auth::BaseClient` credentials object, including but not limited to
+      #       a `Signet::OAuth2::Client` object.
       #   * Any credentials object that supports the methods this wrapper delegates to an inner client.
       #
       #   If this parameter is an object (`Signet::OAuth2::Client` or other) it will be used as an inner client.
@@ -391,14 +394,20 @@ module Google
       #   parameters of the `Signet::OAuth2::Client`, such as connection parameters,
       #   timeouts, etc.
       #
+      # @raise [Google::Auth::InitializationError] If source_creds is nil
+      # @raise [ArgumentError] If both scope and target_audience are specified
+      #
       def initialize source_creds, options = {}
-        raise "The source credentials passed to Google::Auth::Credentials.new were nil." if source_creds.nil?
+        if source_creds.nil?
+          raise InitializationError,
+                "The source credentials passed to Google::Auth::Credentials.new were nil."
+        end
 
         options = symbolize_hash_keys options
         @project_id = options[:project_id] || options[:project]
         @quota_project_id = options[:quota_project_id]
         case source_creds
-        when String
+        when String, Pathname
           update_from_filepath source_creds, options
         when Hash
           update_from_hash source_creds, options
@@ -554,9 +563,12 @@ module Google
       protected
 
       # Verify that the keyfile argument is a file.
+      #
+      # @param [String] keyfile Path to the keyfile
+      # @raise [Google::Auth::InitializationError] If the keyfile does not exist
       def verify_keyfile_exists! keyfile
         exists = ::File.file? keyfile
-        raise "The keyfile '#{keyfile}' is not a valid file." unless exists
+        raise InitializationError, "The keyfile '#{keyfile}' is not a valid file." unless exists
       end
 
       # Initializes the Signet client.
@@ -577,6 +589,11 @@ module Google
         hash.to_h.transform_keys(&:to_sym)
       end
 
+      # Updates client options with defaults from the credential class
+      #
+      # @param [Hash] options Options to update
+      # @return [Hash] Updated options hash
+      # @raise [ArgumentError] If both scope and target_audience are specified
       def update_client_options options
         options = options.dup