bitget.rb 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b63d59a8aebe65c300d42fe6dec98145f4efe93d21f7054f0ec9e076031dca9
-  data.tar.gz: 795de1366e0ddf3194c5a43b1ccac0910b7acc8ad2798982957cd350b10d8483
+  metadata.gz: 68ebcc266ecbdcc502c80abf56f670fd7b0d274e1cee117dafdff7fed81f02de
+  data.tar.gz: 9e59c895f487eef1ffa14f3d88266fcd6ae87a79864dc8ed9f0ff28b63afadf3
 SHA512:
-  metadata.gz: 4d6585e095c3a376910d5c0f282ccf13e10868fd7dcffb944bfa9ce01ac21ecd741827e0fce768ffa7d6467a5d002e7dddf14a03f5d351d33e8dc87dfdfd1992
-  data.tar.gz: ba02b1df209e591007cc18901448c711dfe630085b01796dd67d617db3fd4331c5f233ea1761c59789683502acf0e5df2367242f0f33b29e7675239a1d93abf0
+  metadata.gz: 1dda1a6e29afc914c90cfeb318b0250d10fbe9a04e12502a842e7a1b908baf0f45ed27e51e4be89c5035988553ee6dfc6bf0ff4197cb993f03b3a8aa50560f26
+  data.tar.gz: 7d5f81ce7c5b2b3c943015724b81b0ab7e7d4868f2935b00fb570f66dd5e7d03c6e6b83fad8ef3cf9c08a9fa347394ff9b5186420978c2849f546bd4814bb19a

data/README.md

@@ -30,6 +30,65 @@ bitget_client = Bitget::Client.new(
 )
 ```
 
+### Configuration
+
+Settings may be declared once, and every client built afterwards reads them as its defaults.
+
+```ruby
+Bitget.configure do |config|
+  config.api_key = 'api_key0'
+  config.api_secret = 'api_secret0'
+  config.api_passphrase = 'api_passphrase0'
+end
+
+bitget_client = Bitget::Client.new
+```
+
+The settings are `api_key`, `api_secret`, `api_passphrase`, `debug` and `logger`.
+
+Any of them may still be given per client, which wins over the configured value. The
+credentials are named arguments; the rest go under `options`.
+
+```ruby
+bitget_client = Bitget::Client.new(
+  api_key: 'api_key1',
+  options: {logger: Logger.new('bitget.log', 'daily')}
+)
+```
+
+### Logging
+
+A client logs when it has somewhere to log to, and not at all when it does not. Hand it any
+object answering to `#info` and `#error`; the standard library's `Logger` will do.
+
+```ruby
+require 'logger'
+
+Bitget.configure do |config|
+  config.logger = Logger.new($stdout)
+end
+```
+
+`Logger` rotates by itself, so a daily log file wants no more than its second argument. It
+will not create the directory, so make that first.
+
+```ruby
+require 'fileutils'
+require 'logger'
+
+log_file_path = File.expand_path(File.join(%w{~ log bitget log.txt}))
+FileUtils.mkdir_p(File.dirname(log_file_path))
+
+Bitget.configure do |config|
+  config.logger = Logger.new(log_file_path, 'daily')
+end
+```
+
+Before 0.6.0 the client chose the path, created the directory and rotated the file itself. It
+no longer does any of that: what is logged is the client's business and where it goes is
+yours, which is what lets a StringIO logger in a test, or a levelled one, or something which
+is not a Logger at all, work as well as the above.
+
 ### Retrieve Info on All the Coins Traded
 ```ruby
 bitget_client.spot_public_coins

data/lib/Bitget/Configuration.rb

@@ -0,0 +1,32 @@
+# Bitget/Configuration.rb
+# Bitget::Configuration
+
+module Bitget
+  class Configuration
+    attr_accessor :api_key, :api_secret, :api_passphrase, :debug, :logger
+
+    def initialize
+      @api_key = nil
+      @api_secret = nil
+      @api_passphrase = nil
+      @debug = false
+      @logger = nil
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/Bitget/Error.rb

@@ -1,9 +1,31 @@
 # Bitget/Error.rb
 # Bitget::Error
 
+require 'json'
+
 module Bitget
   class Error < RuntimeError
-    attr_reader :code, :message, :body
+    attr_reader\
+      :code,
+      :message,
+      :body
+
+    # Bitget answers most errors with a JSON body carrying its own code and
+    # message, which are more use than the HTTP ones.  Not all of them: a 418
+    # arrives with an empty body and there is nothing to parse.  Where the body
+    # says nothing the HTTP code and message answer instead, so that an error
+    # renders as something rather than as a pair of blanks.
+    def error_code
+      @parsed_body['code'] || @code
+    end
+
+    def error_message
+      @parsed_body['msg'] || @parsed_body['message'] || @message
+    end
+
+    def to_s
+      "Bitget::Error: #{error_code} - #{error_message}"
+    end
 
     private
 
@@ -11,6 +33,16 @@ module Bitget
       @code = code
       @message = message
       @body = body
+      @parsed_body = parsed(body)
+    end
+
+    # An error is raised in answer to something already having gone wrong, so it
+    # must construct from whatever arrived.  Raising a JSON::ParserError from
+    # here loses the error being reported and replaces it with one about parsing.
+    def parsed(body)
+      JSON.parse(body)
+    rescue JSON::ParserError
+      {}
     end
   end
 end

data/lib/Bitget/V2/Client.rb

@@ -8,8 +8,8 @@ require 'json'
 require 'logger'
 require 'openssl'
 
+require_relative '../Configuration'
 require_relative '../Error'
-require_relative '../../Hash/x_www_form_urlencode'
 
 module Bitget
   module V2
@@ -18,28 +18,11 @@ module Bitget
       API_HOST = 'api.bitget.com'
 
       class << self
-        attr_writer :log_file_path
 
         def path_prefix
           '/api/v2'
         end
 
-        def default_log_file_path
-          File.join(%w{~ log bitget log.txt})
-        end
-
-        def log_file_path
-          File.expand_path(@log_file_path || default_log_file_path)
-        end
-
-        def log_file
-          FileUtils.mkdir_p(File.dirname(log_file_path))
-          File.open(log_file_path, File::WRONLY | File::APPEND | File::CREAT)
-        end
-
-        def logger
-          @logger ||= Logger.new(log_file, 'daily')
-        end
       end # class << self
 
       # Market
@@ -1824,15 +1807,22 @@ module Bitget
         :api_key,
         :api_secret,
         :api_passphrase,
-        :use_logging
+        :debug,
+        :logger
 
       private
 
-      def initialize(api_key:, api_secret:, api_passphrase:, use_logging: false)
-        @api_key = api_key
-        @api_secret = api_secret
-        @api_passphrase = api_passphrase
-        @use_logging = use_logging
+      # Anything not given here is taken from Bitget.configuration, so that a
+      # setting declared once need not be repeated at every call site.  The
+      # credentials fall back upon nil, having no meaningful nil value of their
+      # own; the options ask whether the key was given, nil being a value a
+      # caller may mean for a logger.
+      def initialize(api_key: nil, api_secret: nil, api_passphrase: nil, options: {})
+        @api_key = api_key || Bitget.configuration.api_key
+        @api_secret = api_secret || Bitget.configuration.api_secret
+        @api_passphrase = api_passphrase || Bitget.configuration.api_passphrase
+        @debug = options.key?(:debug) ? options[:debug] : Bitget.configuration.debug
+        @logger = options.key?(:logger) ? options[:logger] : Bitget.configuration.logger
       end
 
       def full_path(path)
@@ -1845,7 +1835,8 @@ module Bitget
       end
 
       def timestamp
-        @timestamp ||= (Time.now.to_f * 1000).to_i.to_s
+        # @timestamp ||= (Time.now.to_f * 1000).to_i.to_s
+        @timestamp ||= (Time.now.to_i * 1000).to_s
       end
 
       def message(verb:, path:, args:)
@@ -1884,6 +1875,10 @@ module Bitget
         }
       end
 
+      def use_logging?
+        !@logger.nil?
+      end
+
       def log_args?(args)
         !args.values.all?(&:nil?)
       end
@@ -1894,21 +1889,21 @@ module Bitget
           log_string << "  Args: #{args}\n"
         end
         log_string << "  Headers: #{headers}\n"
-        self.class.logger.info(log_string)
+        logger.info(log_string)
       end
 
       def log_response(code:, message:, body:)
         log_string = "Code: #{code}\n"
         log_string << "Message: #{message}\n"
         log_string << "Body: #{body}\n"
-        self.class.logger.info(log_string)
+        logger.info(log_string)
       end
 
       def log_error(code:, message:, body:)
         log_string = "Code: #{code}\n"
         log_string << "Message: #{message}\n"
         log_string << "Body: #{body}\n"
-        self.class.logger.error(log_string)
+        logger.error(log_string)
       end
 
       def do_request(verb:, path:, args: {})
@@ -1916,7 +1911,7 @@ module Bitget
         message = message(verb: verb, path: path, args: sorted_args)
         signature = signature(message)
         headers = headers(signature)
-        log_request(verb: verb, request_string: request_string(path), args: sorted_args, headers: headers) if @use_logging
+        log_request(verb: verb, request_string: request_string(path), args: sorted_args, headers: headers) if use_logging?
         @timestamp = nil
         HTTP.send(verb.to_s.downcase, request_string(path), sorted_args, headers)
       end
@@ -1932,23 +1927,11 @@ module Bitget
       def handle_response(response)
         if response.success?
           parsed_body = JSON.parse(response.body)
-          log_response(
-            code: response.code,
-            message: response.message,
-            body: response.body
-          ) if @use_logging
+          log_response(code: response.code, message: response.message, body: response.body) if use_logging?
           parsed_body
         else
-          log_error(
-            code: response.code,
-            message: response.message,
-            body: response.body
-          ) if @use_logging
-          raise Bitget::Error.new(
-            code: response.code,
-            message: response.message,
-            body: response.body
-          )
+          log_error(code: response.code, message: response.message, body: response.body) if use_logging?
+          raise Bitget::Error.new(code: response.code, message: response.message, body: response.body)
         end
       end
     end

data/lib/Bitget/{VERSiON.rb → VERSION.rb}

@@ -2,5 +2,5 @@
 # Bitget::VERSION
 
 module Bitget
-  VERSION = '0.5.0'
+  VERSION = '0.6.1'
 end

data/lib/{bitget.rb → Bitget.rb}

@@ -4,3 +4,5 @@ lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
 
 require_relative './Bitget/Client'
+
+module Bitget; end

data/test/Configuration_test.rb

@@ -0,0 +1,87 @@
+require_relative './helper'
+
+describe Bitget::Configuration do
+  describe "#initialize" do
+    it "sets default values" do
+      config = Bitget::Configuration.new
+      _(config.debug).must_equal(false)
+      _(config.api_key).must_be_nil
+      _(config.api_secret).must_be_nil
+      _(config.api_passphrase).must_be_nil
+      _(config.logger).must_be_nil
+    end
+
+    it "declares a setting for everything a client reads" do
+      _(Bitget::Configuration.new.public_methods(false).grep(/[^=]\z/).sort) \
+        .must_equal(%i{api_key api_passphrase api_secret debug logger})
+    end
+  end
+
+  # The credentials are named arguments and fall back upon nil, having no
+  # meaningful nil of their own.  The options are given under options: and fall
+  # back upon the key being absent, nil being a value a caller may mean.
+  describe "the credentials, which are named arguments" do
+    before do
+      Bitget.configure do |config|
+        config.api_key = 'configured_key'
+        config.api_secret = 'configured_secret'
+        config.api_passphrase = 'configured_passphrase'
+      end
+    end
+
+    it "supplies every one, so that a client needs no arguments at all" do
+      client = Bitget::Client.new
+      _(client.api_key).must_equal('configured_key')
+      _(client.api_secret).must_equal('configured_secret')
+      _(client.api_passphrase).must_equal('configured_passphrase')
+    end
+
+    it "yields to each one given, and only to that one" do
+      _(Bitget::Client.new(api_key: 'given').api_key).must_equal('given')
+      _(Bitget::Client.new(api_key: 'given').api_secret).must_equal('configured_secret')
+      _(Bitget::Client.new(api_secret: 'given').api_secret).must_equal('given')
+      _(Bitget::Client.new(api_secret: 'given').api_key).must_equal('configured_key')
+      _(Bitget::Client.new(api_passphrase: 'given').api_passphrase).must_equal('given')
+      _(Bitget::Client.new(api_passphrase: 'given').api_key).must_equal('configured_key')
+    end
+
+    it "is unreachable where nothing is configured and nothing is given" do
+      Bitget.reset_configuration!
+      client = Bitget::Client.new
+      _(client.api_key).must_be_nil
+      _(client.api_secret).must_be_nil
+      _(client.api_passphrase).must_be_nil
+    end
+  end
+
+  describe "the options, which are given under options:" do
+    let(:logger){Logger.new(StringIO.new)}
+
+    before do
+      Bitget.configure do |config|
+        config.debug = true
+        config.logger = logger
+      end
+    end
+
+    it "supplies every one" do
+      client = Bitget::Client.new
+      _(client.debug).must_equal(true)
+      _(client.logger).must_equal(logger)
+    end
+
+    it "yields to each one given, and only to that one" do
+      other = Logger.new(StringIO.new)
+      _(Bitget::Client.new(options: {debug: false}).debug).must_equal(false)
+      _(Bitget::Client.new(options: {debug: false}).logger).must_equal(logger)
+      _(Bitget::Client.new(options: {logger: other}).logger).must_equal(other)
+      _(Bitget::Client.new(options: {logger: other}).debug).must_equal(true)
+    end
+
+    it "takes nil as a value rather than as an absence" do
+      client = Bitget::Client.new(options: {logger: nil})
+      _(client.logger).must_be_nil
+      _(client.send(:use_logging?)).must_equal(false)
+    end
+  end
+end

data/test/V2/{client_test.rb → Client_test.rb}

@@ -1,5 +1,4 @@
 require_relative '../helper'
-require_relative '../../lib/Bitget/V2/Client'
 
 describe Bitget::V2::Client do
   let(:api_key){ENV.fetch('BITGET_API_KEY', '<API_KEY>')}
@@ -14,6 +13,19 @@ describe Bitget::V2::Client do
     )
   end
 
+  describe "where a request is addressed" do
+    # Written out rather than built from API_HOST and .path_prefix, which would
+    # pass however wrong either of them was.
+    it "is the scheme, the host, the version prefix, and the path" do
+      _(client.send(:request_string, '/spot/public/coins')) \
+        .must_equal('https://api.bitget.com/api/v2/spot/public/coins')
+    end
+
+    it "takes its version prefix from the client, which is what makes V2 a class of its own" do
+      _(Bitget::V2::Client.path_prefix).must_equal('/api/v2')
+    end
+  end
+
   # Market
 
   describe "#spot_public_coins" do
@@ -998,12 +1010,12 @@ describe Bitget::V2::Client do
     let(:mock_error){Minitest::Mock.new}
 
     before do
-      client.use_logging = true
+      client.logger = Logger.new(StringIO.new)
       mock_error.expect(:call, nil, [], code: '418', message: "I'm a teapot", body: '')
     end
 
     after do
-      client.use_logging = false
+      client.logger = nil
       mock_error.verify
     end
 
@@ -1070,79 +1082,49 @@ describe Bitget::V2::Client do
   end
 
   describe "logging" do
+    let(:log){StringIO.new}
+
     before do
-      client.use_logging = true
-      FileUtils.rm_f(client.class.log_file_path)
-      client.class.instance_variable_set(:@log_file_path, nil)
-      client.class.instance_variable_set(:@logger, nil)
+      client.logger = Logger.new(log)
     end
 
     after do
-      client.use_logging = false
-      FileUtils.rm_f(client.class.log_file_path)
-    end
-
-    describe "logging configuration" do
-      it "uses the configured log file path" do
-        client.class.log_file_path = '/tmp/path'
-        _(client.class.log_file_path).must_equal(File.expand_path('/tmp/path'))
-      end
-
-      it "creates log directory if it doesn't exist" do
-        nested_path = File.join(Dir.tmpdir, 'bitget_test', 'nested', 'test.log')
-        client.class.log_file_path = nested_path
-        client.class.logger
-        _(File.directory?(File.dirname(nested_path))).must_equal(true)
-      end
-
-      it "creates a daily rotating logger" do
-        _(client.class.logger).must_be_kind_of(Logger)
-        _(File.exist?(client.class.log_file_path)).must_equal(true)
-      end
+      client.logger = nil
     end
 
     describe "request logging" do
       it "logs requests" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_coin_is_supplied') do
-          client.spot_public_coins(coin: 'BTC')
+        VCR.use_cassette("v2/spot/public/coins-when_coin_is_supplied") do
+          client.spot_public_coins(coin: "BTC")
         end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/GET https:\/\/api.bitget.com\/api\/v2\/spot\/public\/coins/)
-        _(log_content).must_match(/Args: \{coin: \"BTC\"}/)
-        _(log_content).must_match(/Headers: .+\"Content-Type\" => \"application\/json\"/)
+        _(log.string).must_match(/GET https:\/\/api.bitget.com\/api\/v2\/spot\/public\/coins/)
+        _(log.string).must_match(/Args: \{coin: "BTC"}/)
+        _(log.string).must_match(/Headers: .+"Content-Type" => "application\/json"/)
       end
     end
 
     describe "response logging" do
       it "logs responses" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_coin_is_supplied') do
-          client.spot_public_coins(coin: 'BTC')
+        VCR.use_cassette("v2/spot/public/coins-when_coin_is_supplied") do
+          client.spot_public_coins(coin: "BTC")
         end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/Code:/)
-        _(log_content).must_match(/Message:/)
-        _(log_content).must_match(/Body:/)
+        _(log.string).must_match(/Code:/)
+        _(log.string).must_match(/Message:/)
+        _(log.string).must_match(/Body:/)
       end
     end
 
     describe "error logging" do
       it "logs error responses" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_error_occurs') do
+        VCR.use_cassette("v2/spot/public/coins-when_error_occurs") do
           begin
-            client.spot_public_coins(coin: 'INVALID')
+            client.spot_public_coins(coin: "INVALID")
           rescue Bitget::Error
           end
         end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/Code:/)
-        _(log_content).must_match(/Message:/)
-        _(log_content).must_match(/Body:/)
+        _(log.string).must_match(/Code:/)
+        _(log.string).must_match(/Message:/)
+        _(log.string).must_match(/Body:/)
       end
     end
   end

data/test/helper.rb

@@ -1,13 +1,27 @@
 require 'minitest/autorun'
-require 'minitest-spec-context'
+require 'minitest/mock'
 require 'minitest/spec'
+require 'minitest-spec-context'
 require 'vcr'
+require 'webmock' # Necessary? Was working without.
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'bitget'
 
 VCR.configure do |config|
-  config.cassette_library_dir = File.expand_path('../fixtures/vcr_cassettes', __FILE__)
+  # config.cassette_library_dir = File.expand_path('../fixtures/vcr_cassettes', __FILE__)
+  config.cassette_library_dir = 'test/fixtures/vcr_cassettes'
+
   config.hook_into :webmock
 
   config.filter_sensitive_data('<API_KEY>'){ENV['BITGET_API_KEY']}
   config.filter_sensitive_data('<API_SECRET>'){ENV['BITGET_API_SECRET'] }
   config.filter_sensitive_data('<API_PASSPHRASE>'){ENV['BITGET_API_PASSPHRASE']}
 end
+
+class Minitest::Test
+  def before_setup
+    super
+    Bitget.reset_configuration!
+  end
+end

data/test/test_all.rb

@@ -1,4 +1,4 @@
 # test/test_all.rb
 
-require_relative './client_test'
-require_relative './V2/client_test'
+require_relative './V2/Client_test'
+require_relative './Configuration_test'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitget.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - thoran
@@ -32,18 +32,16 @@ files:
 - Gemfile
 - README.md
 - bitget.rb.gemspec
+- lib/Bitget.rb
 - lib/Bitget/Client.rb
+- lib/Bitget/Configuration.rb
 - lib/Bitget/Error.rb
 - lib/Bitget/V2/Client.rb
-- lib/Bitget/VERSiON.rb
-- lib/Hash/x_www_form_urlencode.rb
+- lib/Bitget/VERSION.rb
 - lib/String/url_encode.rb
-- lib/Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode.rb
 - lib/Thoran/String/UrlEncode/url_encode.rb
-- lib/bitget.rb
-- test/V2/client_logging_test.rb
-- test/V2/client_test.rb
-- test/client_test.rb
+- test/Configuration_test.rb
+- test/V2/Client_test.rb
 - test/helper.rb
 - test/test_all.rb
 homepage: http://github.com/thoran/bitget.rb
@@ -64,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.18
 specification_version: 4
 summary: Access the Bitget API with Ruby.
 test_files: []

data/lib/Hash/x_www_form_urlencode.rb

@@ -1,7 +0,0 @@
-# Hash/x_www_form_urlencode.rb
-# Hash#x_www_form_urlencode
-
-# 20241009
-# 0.1.0
-
-require 'Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode'

data/lib/Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode.rb

@@ -1,26 +0,0 @@
-# Thoran/Hash/XWwwFormUrlEncode/x_www_form_urlencode.rb
-# Thoran::Hash::XWwwFormUrlEncode#x_www_form_urlencode
-
-# 20241009
-# 0.2.0
-
-# Changes since 0.1:
-# -/0: (The class name and the snake case name are consistent now.)
-# 1. /XWWWFormUrlEncode/XWwwFormUrlEncode/
-
-require 'Thoran/String/UrlEncode/url_encode'
-
-module Thoran
-  module Hash
-    module XWwwFormUrlEncode
-
-      def x_www_form_url_encode(joiner = '&')
-        inject([]){|a,e| a << "#{e.first.to_s.url_encode}=#{e.last.to_s.url_encode}" unless e.last.nil?; a}.join(joiner)
-      end
-      alias_method :x_www_form_urlencode, :x_www_form_url_encode
-
-    end
-  end
-end
-
-Hash.send(:include, Thoran::Hash::XWwwFormUrlEncode)

data/test/V2/client_logging_test.rb

@@ -1,92 +0,0 @@
-require_relative '../helper'
-require_relative '../../lib/Bitget/V2/Client'
-
-describe Bitget::V2::Client do
-  let(:api_key){ENV.fetch('BITGET_API_KEY', '<API_KEY>')}
-  let(:api_secret){ENV.fetch('BITGET_API_SECRET', '<API_SECRET>')}
-  let(:api_passphrase){ENV.fetch('BITGET_API_PASSPHRASE', '<API_PASSPHRASE>')}
-
-  let(:client) do
-    Bitget::V2::Client.new(
-      api_key: api_key,
-      api_secret: api_secret,
-      api_passphrase: api_passphrase
-    )
-  end
-
-  describe "logging" do
-    before do
-      FileUtils.rm_f(client.class.log_file_path)
-      client.class.instance_variable_set(:@log_file_path, nil)
-      client.class.instance_variable_set(:@logger, nil)
-    end
-
-    after do
-      FileUtils.rm_f(client.class.log_file_path)
-    end
-
-    describe "logging configuration" do
-      it "uses the configured log file path" do
-        client.class.log_file_path = '/some/path'
-        _(client.class.log_file_path).must_equal(File.expand_path('/some/path'))
-      end
-
-      it "creates log directory if it doesn't exist" do
-        nested_path = File.join(Dir.tmpdir, 'bitget_test', 'nested', 'test.log')
-        client.class.log_file_path = nested_path
-        client.class.logger
-        _(File.directory?(File.dirname(nested_path))).must_equal(true)
-      end
-
-      it "creates a daily rotating logger" do
-        _(client.class.logger).must_be_kind_of(Logger)
-        _(File.exist?(client.class.log_file_path)).must_equal(true)
-      end
-    end
-
-    describe "request logging" do
-      it "logs requests" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_coin_is_supplied') do
-          client.spot_public_coins(coin: 'BTC')
-        end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/GET https:\/\/api.bitget.com\/api\/v2\/spot\/public\/coins/)
-        _(log_content).must_match(/Args: \{coin: \"BTC\"}/)
-        _(log_content).must_match(/Headers: .+\"Content-Type\" => \"application\/json\"/)
-      end
-    end
-
-    describe "response logging" do
-      it "logs responses" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_coin_is_supplied') do
-          client.spot_public_coins(coin: 'BTC')
-        end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/Code:/)
-        _(log_content).must_match(/Message:/)
-        _(log_content).must_match(/Body:/)
-      end
-    end
-
-    describe "error logging" do
-      it "logs error responses" do
-        client.class.logger
-        VCR.use_cassette('v2/spot/public/coins-when_error_occurs') do
-          begin
-            client.spot_public_coins(coin: 'INVALID')
-          rescue Bitget::Error
-          end
-        end
-        client.class.logger.close
-        log_content = File.read(client.class.log_file_path)
-        _(log_content).must_match(/Code:/)
-        _(log_content).must_match(/Message:/)
-        _(log_content).must_match(/Body:/)
-      end
-    end
-  end
-end

data/test/client_test.rb

@@ -1,198 +0,0 @@
-require_relative './helper'
-require_relative '../lib/Bitget/Client'
-
-describe Bitget::Client do
-  let(:client) do
-    Bitget::Client.new(
-      api_key: ENV.fetch('BITGET_API_KEY', '<API_KEY>'),
-      api_secret: ENV.fetch('BITGET_API_SECRET', '<API_SECRET>'),
-      api_passphrase: ENV.fetch('BITGET_API_PASSPHRASE', '<API_PASSPHRASE>')
-    )
-  end
-
-  # Market
-
-  %w[
-    spot_public_coins
-    spot_public_symbols
-    spot_market_vip_free_rate
-    spot_market_tickers
-    spot_market_merge_depth
-    spot_market_orderbook
-    spot_market_candles
-    spot_market_history_candles
-    spot_market_fills
-    spot_market_fills_history
-  ].each do |method|
-    describe "##{method}" do
-      it "delegates to V2::Client" do
-        mock_v2_client = Minitest::Mock.new
-        client.instance_variable_set(:@v2_client, mock_v2_client)
-
-        args = case method
-        when 'spot_market_merge_depth', 'spot_market_orderbook'
-          {symbol: 'BTCUSDT'}
-        when 'spot_market_candles', 'spot_market_history_candles'
-          {symbol: 'BTCUSDT', granularity: '1min'}
-        when 'spot_market_fills', 'spot_market_fills_history'
-          {symbol: 'BTCUSDT'}
-        else
-          {}
-        end
-
-        mock_v2_client.expect(method.to_sym, nil, [args])
-        client.send(method, **args)
-        mock_v2_client.verify
-      end
-    end
-  end
-
-  # Trade
-
-  %w[
-    spot_trade_place_order
-    spot_trade_cancel_replace_order
-    spot_trade_batch_cancel_replace_order
-    spot_trade_cancel_order
-    spot_trade_batch_orders
-    spot_trade_batch_cancel_order
-    spot_trade_cancel_symbol_order
-    spot_trade_order_info
-    spot_trade_unfilled_orders
-    spot_trade_history_orders
-    spot_trade_fills
-  ].each do |method|
-    describe "##{method}" do
-      it "delegates to V2::Client" do
-        mock_v2_client = Minitest::Mock.new
-        client.instance_variable_set(:@v2_client, mock_v2_client)
-
-        args = case method
-        when 'spot_trade_place_order'
-          {
-            symbol: 'BTCUSDT',
-            side: 'buy',
-            order_type: 'limit',
-            force: 'normal',
-            size: '0.001',
-            price: '30000'
-          }
-        when /cancel|modify|info/
-          {symbol: 'BTCUSDT', order_id: '123456'}
-        when /batch/
-          {symbol: 'BTCUSDT', order_ids: ['123', '456']}
-        else
-          {symbol: 'BTCUSDT'}
-        end
-
-        mock_v2_client.expect(method.to_sym, nil, [args])
-        client.send(method, **args)
-        mock_v2_client.verify
-      end
-    end
-  end
-
-  # Trigger
-
-  %w[
-    spot_trade_place_plan_order
-    spot_trade_modify_plan_order
-    spot_trade_cancel_plan_order
-    spot_trade_current_plan_order
-    spot_trade_plan_sub_order
-    spot_trade_history_plan_order
-    spot_trade_batch_cancel_plan_order
-  ].each do |method|
-    describe "##{method}" do
-      it "delegates to V2::Client" do
-        mock_v2_client = Minitest::Mock.new
-        client.instance_variable_set(:@v2_client, mock_v2_client)
-
-        args = case method
-        when 'spot_trade_place_plan_order'
-          {
-            symbol: 'BTCUSDT',
-            side: 'buy',
-            order_type: 'limit',
-            size: '0.001',
-            trigger_price: '31000',
-            execute_price: '30000'
-          }
-        when 'spot_trade_modify_plan_order'
-          {
-            order_id: '123456',
-            trigger_price: '31000',
-            execute_price: '30000',
-            size: '0.001'
-          }
-        when 'spot_trade_cancel_plan_order'
-          {order_id: '123456'}
-        when 'spot_trade_plan_sub_order'
-          {order_id: '123456'}
-        when 'spot_trade_batch_cancel_plan_order'
-          {symbol: 'BTCUSDT', order_ids: ['123', '456']}
-        else
-          {symbol: 'BTCUSDT'}
-        end
-
-        mock_v2_client.expect(method.to_sym, nil, [args])
-        client.send(method, **args)
-        mock_v2_client.verify
-      end
-    end
-  end
-
-  # Account
-
-  %w[
-    spot_account_info
-    spot_account_assets
-    spot_account_subaccount_assets
-    spot_account_bills
-    spot_account_sub_main_trans_record
-    spot_account_transfer_records
-    spot_account_switch_deduct
-    spot_account_deduct_info
-    spot_wallet_modify_deposit_account
-    spot_wallet_transfer
-    spot_wallet_transfer_coin_info
-    spot_wallet_subaccount_transfer
-    spot_wallet_withdrawal
-    spot_wallet_cancel_withdrawal
-    spot_wallet_deposit_address
-    spot_wallet_subaccount_deposit_address
-    spot_wallet_subaccount_deposit_records
-    spot_wallet_withdrawal_records
-    spot_wallet_deposit_records
-  ].each do |method|
-    describe "##{method}" do
-      it "delegates to V2::Client" do
-        mock_v2_client = Minitest::Mock.new
-        client.instance_variable_set(:@v2_client, mock_v2_client)
-
-        args = case method
-        when 'spot_wallet_withdrawal'
-          {
-            coin: 'USDT',
-            chain: 'TRC20',
-            address: '0x1234567890abcdef',
-            amount: '100'
-          }
-        when /transfer/
-          {
-            coin: 'USDT',
-            amount: '100'
-          }
-        when /subaccount/
-          {subaccount_id: '123456'}
-        else
-          {}
-        end
-
-        mock_v2_client.expect(method.to_sym, nil, [args])
-        client.send(method, **args)
-        mock_v2_client.verify
-      end
-    end
-  end
-end