minato_ruby_api_client 0.2.1 → 0.2.3

data/spec/api_client_spec.rb

@@ -306,4 +306,46 @@ describe MinatoRubyApiClient::ApiClient do
       end
     end
   end
+
+  describe '#log_response' do
+    let(:config) { MinatoRubyApiClient::Configuration.new }
+    let(:logger) { Logger.new(STDOUT) }
+    let(:api_client) { described_class.new(config) }
+    
+    before do
+      allow(config).to receive(:logger).and_return(logger)
+    end
+    
+    context 'when response has JSON content type' do
+      it 'logs response with full details' do
+        response = double('response',
+          env: double(url: 'https://api.example.com/test'),
+          headers: { 'Content-Type' => 'application/json' },
+          to_hash: { status: 200, body: '{"success": true}' }
+        )
+        
+        expect(logger).to receive(:info).with({
+          'message' => 'Receive response from https://api.example.com/test',
+          'http_response' => { status: 200, body: '{"success": true}' }
+        })
+        
+        api_client.send(:log_response, response)
+      end
+    end
+    
+    context 'when response has binary content type' do
+      it 'logs only message without response details' do
+        response = double('response',
+          env: double(url: 'https://api.example.com/download'),
+          headers: { 'Content-Type' => 'application/pdf' }
+        )
+        
+        expect(logger).to receive(:info).with({
+          'message' => 'Receive response from https://api.example.com/download'
+        })
+        
+        api_client.send(:log_response, response)
+      end
+    end
+  end
 end

data/spec/configuration_spec.rb

@@ -1,204 +1,204 @@
-require 'spec_helper'
-
-describe MinatoRubyApiClient::Configuration do
-  let(:url) { 'https://example.com/v1' }
-
-  before :each do
-    require 'uri'
-    uri = URI.parse(url)
-    MinatoRubyApiClient.configure do |c|
-      c.host = uri.host
-      c.base_path = uri.path
-      c.api_key['api_key'] = 'test_key'
-    end
-
-    @config = described_class.default
-  end
-
-  describe '#scheme' do
-    it 'should have the default value https' do
-      expect(@config.scheme).to eq('https')
-    end
-
-    it 'should remove :// from scheme' do
-      @config.scheme = 'https://'
-      expect(@config.scheme).to eq('https')
-    end
-  end
-
-  describe '#host' do
-    it 'should do not have the scheme value' do
-      expect(@config.host).not_to match(/https/)
-    end
-  end
-
-  describe '#base_path' do
-    it 'should add leading slashes if missing' do
-      @config.base_path = 'v1'
-      expect(@config.base_path).to eq('/v1')
-    end
-
-    it 'should be empty if is /' do
-      @config.base_path = '/'
-      expect(@config.base_path).to eq('')
-    end
-  end
-
-  describe '#user_agent' do
-  it 'should have user agent' do
-    @config.user_agent = 'Minato'
-    expect(@config.user_agent).to eq('Minato')
-  end
-end
-
-  describe '#base_url' do
-    it 'should have the default value' do
-      expect(@config.base_url).to eq(url)
-    end
-
-    it 'should remove trailing slashes' do
-      [nil, '', '/', '//'].each do |base_path|
-        @config.base_path = base_path
-        expect(@config.base_url).to eq("https://example.com")
-      end
-    end
-  end
-
-  describe '#timeout' do
-    it 'should have the default value' do
-      expect(@config.timeout).to eq(60)
-    end
-  end
-
-  describe '#debugging' do
-    it 'should have the default value falsy' do
-      expect(@config.debugging).to be_falsy
-    end
-
-    context 'when MINATO_RUBY_API_CLIENT_DEBUG is true' do
-      it 'should be truthy' do
-        allow(ENV).to receive(:[]).with('MINATO_RUBY_API_CLIENT_DEBUG').and_return('true')
-        expect(@config.debugging).to be_truthy
-      end
-    end
-
-    context 'when debug is active' do
-      it 'should be truthy' do
-        config = described_class.new
-        config.debugging = true
-        expect(config.debugging).to be_truthy
-      end
-    end
-  end
-
-  describe '#auth_settings' do
-    it 'should have default auth types' do
-      expect(@config.auth_settings.keys).to eq(%w[bearer_auth basic_auth apikey])
-    end
-  end
-
-  describe '#basic_auth_token' do
-    let(:username) { 'test' }
-    let(:password) { 'test' }
-    let(:token) { ["#{username}:#{password}"].pack('m').delete("\r\n") }
-    it 'should return basic auth string' do
-      @config.username = username
-      @config.password = password
-      expect(@config.basic_auth_token).to eq("Basic #{token}")
-    end
-  end
-
-  describe '#logger' do
-    let(:logger) { Logger.new(STDOUT) }
-
-    context 'when Rails is defined' do
-      it 'should return Rails.logger' do
-        allow(Object).to receive(:const_defined?).with(:Rails).and_return(true)
-        allow(Rails).to receive(:logger).and_return(logger)
-        config = described_class.new
-        expect(config.logger).to eq(Rails.logger)
-      end
-    end
-
-    context 'when Rails is not defined' do
-      it 'should return Logger instance' do
-        allow(Object).to receive(:const_defined?).with(:Rails).and_return(nil)
-        config = described_class.new
-        expect(config.logger).to be_instance_of(Logger)
-      end
-    end
-  end
-
-  describe '#api_key_with_prefix' do
-    context 'when api_key_prefix is not defined' do
-      it 'return the key without prefix' do
-        expect(@config.api_key_with_prefix('api_key')).to eq('test_key')
-      end
-    end
-
-    context 'when api_key_prefix is defined' do
-      it 'return the key with prefix' do
-        @config.api_key_prefix['api_key'] = 'Prefix'
-        expect(@config.api_key_with_prefix('api_key')).to eq('Prefix test_key')
-      end
-    end
-  end
-
-  describe '#configure' do
-    context 'when block is given' do
-      it 'should yield the configuration object' do
-        expect { |b| @config.configure(&b) }.to yield_with_args
-      end
-    end
-
-    context 'when block is not given' do
-      it 'should return nil' do
-        expect(@config.configure).to be_nil
-      end
-    end   
-  end
-
-  describe '#use' do
-    it 'add middleware to the middlewares list' do
-      @config.use(:test)
-      expect(@config.instance_variable_get('@middlewares')).to include([:test])
-    end
-  end
-
-  describe '#request' do
-    it 'add middleware to the request middlewares list' do
-      @config.request(:test)
-      expect(@config.instance_variable_get('@request_middlewares')).to include([:test])
-    end
-  end
-
-  describe '#response' do
-    it 'add middleware to the response middlewares list' do
-      @config.response(:test)
-      expect(@config.instance_variable_get('@response_middlewares')).to include([:test])
-    end
-  end
-
-  describe '#configure_middleware' do
-    let(:conn) { double('conn') }
-    let(:config) { described_class.new }
-
-    before do
-      config.use(:use)
-      config.request(:request)
-      config.response(:response)
-
-      allow(conn).to receive(:use)
-      allow(conn).to receive(:request)
-      allow(conn).to receive(:response)
-
-      config.configure_middleware(conn)
-    end
-
-    it 'add middlewares to connection middleware stack' do
-      expect(conn).to have_received(:use).once.with(:use)
-      expect(conn).to have_received(:request).once.with(:request)
-      expect(conn).to have_received(:response).once.with(:response)
-    end
-  end
-end
+require 'spec_helper'
+
+describe MinatoRubyApiClient::Configuration do
+  let(:url) { 'https://example.com/v1' }
+
+  before :each do
+    require 'uri'
+    uri = URI.parse(url)
+    MinatoRubyApiClient.configure do |c|
+      c.host = uri.host
+      c.base_path = uri.path
+      c.api_key['api_key'] = 'test_key'
+    end
+
+    @config = described_class.default
+  end
+
+  describe '#scheme' do
+    it 'should have the default value https' do
+      expect(@config.scheme).to eq('https')
+    end
+
+    it 'should remove :// from scheme' do
+      @config.scheme = 'https://'
+      expect(@config.scheme).to eq('https')
+    end
+  end
+
+  describe '#host' do
+    it 'should do not have the scheme value' do
+      expect(@config.host).not_to match(/https/)
+    end
+  end
+
+  describe '#base_path' do
+    it 'should add leading slashes if missing' do
+      @config.base_path = 'v1'
+      expect(@config.base_path).to eq('/v1')
+    end
+
+    it 'should be empty if is /' do
+      @config.base_path = '/'
+      expect(@config.base_path).to eq('')
+    end
+  end
+
+  describe '#user_agent' do
+  it 'should have user agent' do
+    @config.user_agent = 'Minato'
+    expect(@config.user_agent).to eq('Minato')
+  end
+end
+
+  describe '#base_url' do
+    it 'should have the default value' do
+      expect(@config.base_url).to eq(url)
+    end
+
+    it 'should remove trailing slashes' do
+      [nil, '', '/', '//'].each do |base_path|
+        @config.base_path = base_path
+        expect(@config.base_url).to eq("https://example.com")
+      end
+    end
+  end
+
+  describe '#timeout' do
+    it 'should have the default value' do
+      expect(@config.timeout).to eq(60)
+    end
+  end
+
+  describe '#debugging' do
+    it 'should have the default value falsy' do
+      expect(@config.debugging).to be_falsy
+    end
+
+    context 'when MINATO_RUBY_API_CLIENT_DEBUG is true' do
+      it 'should be truthy' do
+        allow(ENV).to receive(:[]).with('MINATO_RUBY_API_CLIENT_DEBUG').and_return('true')
+        expect(@config.debugging).to be_truthy
+      end
+    end
+
+    context 'when debug is active' do
+      it 'should be truthy' do
+        config = described_class.new
+        config.debugging = true
+        expect(config.debugging).to be_truthy
+      end
+    end
+  end
+
+  describe '#auth_settings' do
+    it 'should have default auth types' do
+      expect(@config.auth_settings.keys).to eq(%w[bearer_auth basic_auth apikey])
+    end
+  end
+
+  describe '#basic_auth_token' do
+    let(:username) { 'test' }
+    let(:password) { 'test' }
+    let(:token) { ["#{username}:#{password}"].pack('m').delete("\r\n") }
+    it 'should return basic auth string' do
+      @config.username = username
+      @config.password = password
+      expect(@config.basic_auth_token).to eq("Basic #{token}")
+    end
+  end
+
+  describe '#logger' do
+    let(:logger) { Logger.new(STDOUT) }
+
+    context 'when Rails is defined' do
+      it 'should return Rails.logger' do
+        allow(Object).to receive(:const_defined?).with(:Rails).and_return(true)
+        allow(Rails).to receive(:logger).and_return(logger)
+        config = described_class.new
+        expect(config.logger).to eq(Rails.logger)
+      end
+    end
+
+    context 'when Rails is not defined' do
+      it 'should return Logger instance' do
+        allow(Object).to receive(:const_defined?).with(:Rails).and_return(nil)
+        config = described_class.new
+        expect(config.logger).to be_instance_of(Logger)
+      end
+    end
+  end
+
+  describe '#api_key_with_prefix' do
+    context 'when api_key_prefix is not defined' do
+      it 'return the key without prefix' do
+        expect(@config.api_key_with_prefix('api_key')).to eq('test_key')
+      end
+    end
+
+    context 'when api_key_prefix is defined' do
+      it 'return the key with prefix' do
+        @config.api_key_prefix['api_key'] = 'Prefix'
+        expect(@config.api_key_with_prefix('api_key')).to eq('Prefix test_key')
+      end
+    end
+  end
+
+  describe '#configure' do
+    context 'when block is given' do
+      it 'should yield the configuration object' do
+        expect { |b| @config.configure(&b) }.to yield_with_args
+      end
+    end
+
+    context 'when block is not given' do
+      it 'should return nil' do
+        expect(@config.configure).to be_nil
+      end
+    end   
+  end
+
+  describe '#use' do
+    it 'add middleware to the middlewares list' do
+      @config.use(:test)
+      expect(@config.instance_variable_get('@middlewares')).to include([:test])
+    end
+  end
+
+  describe '#request' do
+    it 'add middleware to the request middlewares list' do
+      @config.request(:test)
+      expect(@config.instance_variable_get('@request_middlewares')).to include([:test])
+    end
+  end
+
+  describe '#response' do
+    it 'add middleware to the response middlewares list' do
+      @config.response(:test)
+      expect(@config.instance_variable_get('@response_middlewares')).to include([:test])
+    end
+  end
+
+  describe '#configure_middleware' do
+    let(:conn) { double('conn') }
+    let(:config) { described_class.new }
+
+    before do
+      config.use(:use)
+      config.request(:request)
+      config.response(:response)
+
+      allow(conn).to receive(:use)
+      allow(conn).to receive(:request)
+      allow(conn).to receive(:response)
+
+      config.configure_middleware(conn)
+    end
+
+    it 'add middlewares to connection middleware stack' do
+      expect(conn).to have_received(:use).once.with(:use)
+      expect(conn).to have_received(:request).once.with(:request)
+      expect(conn).to have_received(:response).once.with(:response)
+    end
+  end
+end

data/spec/minato_ruby_api_client_spec.rb

@@ -1,17 +1,17 @@
-require 'spec_helper'
-
-describe MinatoRubyApiClient do
-  describe '.configure' do
-    context 'when no block is given' do
-      it 'returns the default configuration' do
-        expect(MinatoRubyApiClient.configure).to eq MinatoRubyApiClient::Configuration.default
-      end
-    end
-
-    context 'when a block is given' do
-      it 'yields the configuration' do
-        expect { |b| MinatoRubyApiClient.configure(&b) }.to yield_control
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe MinatoRubyApiClient do
+  describe '.configure' do
+    context 'when no block is given' do
+      it 'returns the default configuration' do
+        expect(MinatoRubyApiClient.configure).to eq MinatoRubyApiClient::Configuration.default
+      end
+    end
+
+    context 'when a block is given' do
+      it 'yields the configuration' do
+        expect { |b| MinatoRubyApiClient.configure(&b) }.to yield_control
+      end
+    end
+  end
+end