update base_spec.

spec/client/base_spec.rb

@@ -3,137 +3,58 @@
 require 'spec_helper'
 
 RSpec.describe BtcPay::Client::Base do
-  let(:config) { create(:config) }
+  let(:config) { build(:config) }
   let(:subject) { described_class.new(config: config) }
 
-  describe '.configuration' do
-    it 'returns host' do
-      expect(subject.host).to eq(host)
-    end
-
-    it 'returns api_key' do
-      expect(subject.api_key).to eq(api_key)
-    end
-
-    it 'returns sandbox' do
-      expect(subject.sandbox).to eq(false)
-    end
-
-    # skipped due to logger being mocked
-    xit 'returns default logger' do
-      expect(subject.logger).to be_a(Logger)
-    end
-
-    it 'raises error when api_key missing' do
-      expect { described_class.new }.to raise_error(KeyError, 'key not found: "CMC_PRO_API_KEY"')
-    end
-
-    context 'host' do
-      it 'defaults to production environment' do
-        subject = described_class.new(api_key: api_key)
-        expect(subject.sandbox).to eq(false)
-        expect(subject.host).to eq('https://pro-api.coinmarketcap.com/v1')
-      end
-
-      it 'defaults to production environment' do
-        subject = described_class.new(api_key: api_key, sandbox: true)
-        expect(subject.sandbox).to eq(true)
-        expect(subject.host).to eq('https://sandbox.coinmarketcap.com/v1')
-      end
-    end
+  describe 'resources' do
+    it { expect(subject.users).to be_a(BtcPay::Client::Api::Users) }
   end
 
-  describe 'services' do
-    it '.cryptocurrency' do
-      expect(subject.cryptocurrency).to be_a(CoinMarketPro::Endpoint::Cryptocurrency)
-    end
-
-    it '.exchange' do
-      expect(subject.exchange).to be_a(CoinMarketPro::Endpoint::Exchange)
-    end
-
-    it '.global_metrics' do
-      expect(subject.global_metrics).to be_a(CoinMarketPro::Endpoint::GlobalMetrics)
-    end
-
-    it '.tools' do
-      expect(subject.tools).to be_a(CoinMarketPro::Endpoint::Tools)
-    end
-  end
-
-  describe '.default_headers' do
-    it do
-      expect(subject.default_headers).to eq(
-        'Content-Type' => 'application/json',
-        'Accept' => 'application/json',
-        'User-Agent' => "coin_market_pro/#{CoinMarketPro::VERSION}",
-        'Accept-Encoding' => 'deflate, gzip',
-        'X-CMC_PRO_API_KEY' => api_key
-      )
-    end
-  end
-
-  describe '.open_timeout' do
-    it { expect(subject.open_timeout).to eq(10) }
-  end
-
-  describe '.timeout' do
-    it { expect(subject.timeout).to eq(10) }
-  end
-
-  describe '.handle_error' do
+  describe 'requests' do
+    let(:path) { '/' }
     let(:response) { double('response') }
-    let(:error) { double('error') }
-    let(:code) { 400 }
-    let(:body) do
-      {
-        data: { id: 1 },
-        status: { code: code }
-      }
-    end
-
-    it 'returns failure status response' do
-      allow(response).to receive(:headers)
-      allow(response).to receive(:body).and_return(body.to_json)
-      expect(response).to receive(:code).at_least(:once).and_return(code)
-
-      expect(error).to receive(:message).and_return('message')
-      expect(error).to receive(:response).and_return(response)
-
-      status = subject.handle_error(error)
-
-      expect(status.failure?).to eq(true)
-    end
-  end
-
-  describe '.get' do
-    let(:response) { double('response') }
-    let(:body) do
-      {
-        data: { id: 1 },
-        status: { code: 200 }
-      }
-    end
+    let(:body) { { data: { id: 1 } } }
 
     before do
       allow(RestClient::Request).to receive(:execute).and_return(response)
       allow(response).to receive(:body).and_return(body.to_json)
-      allow(response).to receive(:headers)
+      allow(response).to receive(:headers).and_return({})
+      allow(response).to receive(:code).and_return(200)
     end
 
-    it 'returns successful status response' do
-      expect(response).to receive(:code).at_least(:once).and_return(200)
-
-      status = subject.get(path)
-      expect(status.success?).to eq(true)
-    end
-
-    context 'error' do
-      it 'returns failure status response' do
-        expect(response).to receive(:code).at_least(:once).and_return(400)
+    context '#get' do
+      it 'returns successful status response' do
+        expect(response).to receive(:code).at_least(:once).and_return(200)
 
         status = subject.get(path)
-        expect(status.failure?).to eq(true)
+        expect(status.success?).to eq(true)
+      end
+
+      context 'error' do
+        it 'returns failure status response' do
+          expect(response).to receive(:code).at_least(:once).and_return(400)
+
+          status = subject.get(path)
+          expect(status.failure?).to eq(true)
+        end
+      end
+    end
+
+    context '#post' do
+      it 'returns successful status response' do
+        expect(response).to receive(:code).at_least(:once).and_return(200)
+
+        status = subject.post(path, payload: {})
+        expect(status.success?).to eq(true)
+      end
+
+      context 'error' do
+        it 'returns failure status response' do
+          expect(response).to receive(:code).at_least(:once).and_return(400)
+
+          status = subject.post(path, payload: {})
+          expect(status.failure?).to eq(true)
+        end
       end
     end
   end