Stuck with refactoring classes on ruby on rails 5

There is a general principle for OO languages to be "lazy" and defer decisions to as late as possible. We'll use that principle to refactor your code to make the token automatically refresh itself on expiration, and/or fetch itself if it has not already done so.

There is also a group of principles known collectively as SOLID. We'll use those principles also.

The final principle I'll reference is "smaller is better", with respect to methods and modules. Combine that with the "S" (Single Responsibility) from SOLID, and you'll see the refactor contains a lot more, but much smaller methods.

Principles aside, it's not clear from the problem statement that the token is short-lived (lasts only for a "session") or long-lived (eg: lasts longer than a single session).

If the token is long-lived, then storing it into a file is okay, if the only processes using it are on the same system.

If multiple web servers will be using this code, then unless each one is to have its own token, the token should be shared across all of the systems using a data store of some kind, like Redis, MySQL, or Postgres.

Since your code is using a file, we'll assume that multiple processes on the same system might be sharing the token.

Given these principles and assumptions, here is a refactoring of your code, using a file to store the token, using "lazy" deferred, modular logic.

class Client
  class Configuration
    attr_accessor :access_token
    attr_reader :access_token_path, :endpoint, :client_id, :client_secret, :subId


    def initialize
      @access_token      = nil
      @access_token_path = Rails.root.join('tmp/connection_response.json')
      @endpoint          = ENV['TOKEN_ENDPOINT']
      @client_id         = ENV['CLIENT_ID']
      @client_secret     = ENV['CLIENT_SECRET']
      @sub_id            = "SOME_ID"
    end
  end
  
  attr_accessor :configuration
  delegate :access_token, :access_token_path, :endpoint, :client_id, :client_secret, :sub_id,
           to: :configuration

  TOKEN_EXPIRATION_TIME = 60 # seconds

  
  def initialize
    @configuration = Configuration.new
  end

  # returns a token, possibly refreshed or fetched for the first time
  def token
    unexpired_token || new_token
  end

  # returns an expired token
  def unexpired_token
    access_token unless token_expired?
  end

  def access_token
    # cache the result until it expires
    @access_token ||= JSON.parse(read_token)&.fetch("access_token", nil)
  end

  def read_token
    File.read(token_path)
  end

  def token_path
    access_token_path&.to_s || raise("No access token path configured!")
  end

  def token_expired?
    # the token expiration time should be in the *future*
    token_expiration_time.nil? || 
      token_expiration_time < (DateTime.now.to_i + TOKEN_EXPIRATION_TIME)
  end

  def token_expiration_time
    # cache the token expiration time; it won't change
    @token_expiration_time ||= decoded_token&.fetch("exp", nil)
  end

  def decoded_token
    @decoded_token ||= JWT.decode(access_token, nil, false).first
  end

  def new_token
    @access_token = store_token(new_access_token)
  end

  def store_token(token)
    @token_expiration_time = nil # reset cached values
    @decoded_token = nil
    IO.write(token_path, token)
    token
  end

  def new_access_token
    parse_token(request_token_response)
  end

  def parse_token(response)
    JSON.parse(response.body)&.fetch("access_token", nil)
  end

  def request_token_response
    RestClient.post(
      endpoint,
      credentials_hash,
      headers: { 'Content-Type' => 'application/x-www-form-urlencoded' }
    )
  end

  def credentials_hash
    {
      grant_type:    "client_credentials",
      client_id:     client_id || raise("Client ID not configured!"),
      client_secret: client_secret || raise("Client secret not configured!")
    }
  end
end

So, how does this work?

Assuming that the client code uses the token, just evaluating the token method will cause the unexpired token to be retrieved or refreshed (if it existed), or a new one fetched (if it hadn't existed).

So, there's no need to "check" for the token before using the @client connection. When the @client connection uses the token, the right stuff will happen.

Values that do not change are cached, to avoid having to redo the logic that produced them. Eg: There is no need to decode the JWT string repeatedly.

When the current token time expires, the token_expired? will turn true, causing its caller to return nil, causing that caller to fetch a new_token, which then gets stored.

The great advantage to these small methods are that each can be tested independently, since they each have a very simple purpose.

Good luck with your project!