oanda_api_v20 1.5.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8108f8ae8240196afbf5ce81fb7cc96f9eeece1
-  data.tar.gz: 97384a79da9a3a293529034eb5f2a483c5c9b96e
+  metadata.gz: 2e44f2d12b3c6e2fafe20137218ecfec9d8f4678
+  data.tar.gz: cec80bbcce9fe58398319d715a2d7a50cc1f37f4
 SHA512:
-  metadata.gz: def31bfcd6716e880495a6396133334fd649c9fa64f42c1b957b4a165bb7b3b3ea74e13be95b3293ababb1f754ad935bd09ab24360ee9a58008e646bd61279f7
-  data.tar.gz: 6ee7cb2047dd8e05eae5da2da3efd859a6dfad1fd1c4f989342b73a9a67e6bd43d8b6145991e1c73ab0c82e6d61a7e94a2ae7679d049af52e0a4a6855c496c1a
+  metadata.gz: 3b4439bf716d67a9117036009817ea19caa302b610b234832b7f7294116df3ab6b5ee6763967c6f4932a0630143367bcf498132f0b689e0c7627f9afdeff6a4e
+  data.tar.gz: 984932b04c7095c02af46a3000a6b2c8935f8062e707d235a45d07afcc43a4f94d719744d83b7277ab64e90525f1e3086982134b6e2ea58c001714bc717d694b

data/.gitignore

@@ -1,3 +1,4 @@
 .byebug_history
 oanda_api_v20-*.gem
 Gemfile.lock
+.DS_Store

data/.travis.yml

@@ -1,3 +1,3 @@
 language: ruby
 rvm:
-  - 2.2
+  - 2.3

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Change Log
 
+## 2.0.0
+#### 2018-04-24
+* Fixed issues when trying to reuse a Client object to make HTTP requests to Oanda.
+* Moved instance variables last_action, last_arguments, instrument and account_id from the Client class to the Api class. They should not be part of a Client object.
+* Removed last_transaction_id instance variable.
+* RubyVM::Logger changed to ::Logger.
+* Added a connection_pool_size option to allow persistent HTTP connection control on the Client object.
+* Added a max_requests_per_second option to allow customized control on the Client max requests per second allowed to Oanda API.
+* Added multithreading support for HTTP request governing. HTTP requests will be correctly allocated across multiple client threads.
+* Raises an OandaApiV20::ApiError exception when no client object was supplied when instantiating an OandaApiV20::Api instance.
+
 ## 1.5.0
 #### 2017-07-07
 * Updated the orders method to allow query options to be passed along.

data/README.md

@@ -37,6 +37,14 @@ If you need your requests to go through a proxy:
 
     client = OandaApiV20.new(access_token: 'my_access_token', proxy_url: 'https://user:pass@proxy.com:80')
 
+You can adjust the persistend connection pool size, the default is 2:
+
+    client = OandaApiV20.new(access_token: 'my_access_token', connection_pool_size: 10)
+
+You can adjust the number of requests per second allowed to Oanda API, the default is 100:
+
+    client = OandaApiV20.new(access_token: 'my_access_token', max_requests_per_second: 10)
+
 ## Examples
 
 ### Accounts
@@ -63,10 +71,6 @@ client.account('account_id').instruments.show
 client.account('account_id').instruments('EUR_USD,EUR_CAD').show
 ```
 
-```ruby
-client.account('account_id').changes.show
-```
-
 ```ruby
 options = { 'sinceTransactionID' => '6358' }
 
@@ -103,6 +107,10 @@ options = { 'instrument' => 'USD_CAD' }
 client.account('account_id').orders(options).show
 ```
 
+```ruby
+client.account('account_id').pending_orders.show
+```
+
 ```ruby
 id = client.account('account_id').orders.show['orders'][0]['id']
 
@@ -128,10 +136,12 @@ id = client.account('account_id').orders.show['orders'][0]['id']
 
 options = {
   'order' => {
+    'instrument' => 'EUR_CAD',
+    'price' => '1.6000',
     'timeInForce' => 'GTC',
-    'price' => '1.7000',
-    'type' => 'TAKE_PROFIT',
-    'tradeID' => '1'
+    'type' => 'MARKET_IF_TOUCHED',
+    'units' => '200',
+    'positionFill' => 'DEFAULT'
   }
 }
 
@@ -182,11 +192,11 @@ id = client.account('account_id').open_trades.show['trades'][0]['id']
 options = {
   'takeProfit' => {
     'timeInForce' => 'GTC',
-    'price' => '0.5'
+    'price' => '2.5'
   },
   'stopLoss' => {
     'timeInForce' => 'GTC',
-    'price' => '2.5'
+    'price' => '0.5'
   }
 }
 

data/lib/oanda_api_v20/accounts.rb

@@ -25,7 +25,7 @@ module OandaApiV20
 
     # GET /v3/accounts/:account_id/changes
     def changes(options = {})
-      options = { 'sinceTransactionID' => last_transaction_id } unless options['sinceTransactionID']
+      options = { 'sinceTransactionID' => nil } unless options['sinceTransactionID']
       Client.send(http_verb, "#{base_uri}/accounts/#{account_id}/changes", headers: headers, query: options)
     end
 

data/lib/oanda_api_v20/api.rb

@@ -8,12 +8,89 @@ module OandaApiV20
     include Transactions
     include Pricing
 
-    attr_accessor :http_verb, :base_uri, :headers, :account_id, :instrument, :last_transaction_id
+    attr_accessor :client, :base_uri, :headers, :account_id, :last_action, :last_arguments
+    attr_writer   :instrument
 
     def initialize(options = {})
       options.each do |key, value|
         self.send("#{key}=", value) if self.respond_to?("#{key}=")
       end
+
+      raise OandaApiV20::ApiError, 'No client object was supplid.' unless client
+      @base_uri ||= client.base_uri
+      @headers  ||= client.headers
+    end
+
+    class << self
+      def api_methods
+        Accounts.instance_methods + Instruments.instance_methods + Orders.instance_methods + Trades.instance_methods + Positions.instance_methods + Transactions.instance_methods + Pricing.instance_methods
+      end
+    end
+
+    self.api_methods.each do |method_name|
+      original_method = instance_method(method_name)
+
+      define_method(method_name) do |*args, &block|
+        # Add the block below before each of the api_methods to set the last_action and last_arguments.
+        # Return the OandaApiV20::Api object to allow for method chaining when any of the api_methods have been called.
+        # Only make an HTTP request to Oanda API When an action method like show, update, cancel, close or create was called.
+        set_last_action_and_arguments(method_name, *args)
+        return self unless http_verb
+
+        original_method.bind(self).call(*args, &block)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      case name
+      when :show, :create, :update, :cancel, :close
+        set_http_verb(name, last_action)
+
+        if respond_to?(last_action)
+          api_result = {}
+          client.update_last_api_request_at
+          client.govern_api_request_rate
+
+          begin
+            response = Http::Exceptions.wrap_and_check do
+              last_arguments.nil? || last_arguments.empty? ? send(last_action, &block) : send(last_action, *last_arguments, &block)
+            end
+          rescue Http::Exceptions::HttpException => e
+            raise OandaApiV20::RequestError, e.message
+          end
+
+          if response.body && !response.body.empty?
+            api_result.merge!(JSON.parse(response.body))
+          end
+        end
+
+        self.http_verb = nil
+        api_result
+      else
+        super
+      end
+    end
+
+    private
+
+    attr_accessor :http_verb
+
+    def set_last_action_and_arguments(action, *args)
+      self.last_action    = action.to_sym
+      self.last_arguments = args
+    end
+
+    def set_http_verb(action, last_action)
+      case action
+      when :show
+        self.http_verb = :get
+      when :update, :cancel, :close
+        [:configuration].include?(last_action) ? self.http_verb = :patch : self.http_verb = :put
+      when :create
+        self.http_verb = :post
+      else
+        self.http_verb = nil
+      end
     end
   end
 end

data/lib/oanda_api_v20/client.rb

@@ -2,14 +2,12 @@ module OandaApiV20
   class Client
     include HTTParty
 
-    MAX_REQUESTS_PER_SECOND_ALLOWED = 30
-
     BASE_URI = {
       live:     'https://api-fxtrade.oanda.com/v3',
       practice: 'https://api-fxpractice.oanda.com/v3'
     }
 
-    attr_accessor :access_token, :proxy_url
+    attr_accessor :access_token, :proxy_url, :max_requests_per_second, :connection_pool_size, :debug
     attr_reader   :base_uri, :headers
 
     def initialize(options = {})
@@ -17,11 +15,14 @@ module OandaApiV20
         self.send("#{key}=", value) if self.respond_to?("#{key}=")
       end
 
-      @debug = options[:debug] || false
-      @last_api_request_at = Array.new(MAX_REQUESTS_PER_SECOND_ALLOWED)
-      @base_uri = options[:practice] == true ? BASE_URI[:practice] : BASE_URI[:live]
+      @mutex                   = Mutex.new
+      @debug                   ||= false
+      @connection_pool_size    ||= 2
+      @max_requests_per_second ||= 100
+      @last_api_request_at     = Array.new(max_requests_per_second)
+      @base_uri                = options[:practice] == true ? BASE_URI[:practice] : BASE_URI[:live]
 
-      @headers = {}
+      @headers                             = {}
       @headers['Authorization']            = "Bearer #{access_token}"
       @headers['X-Accept-Datetime-Format'] = 'RFC3339'
       @headers['Content-Type']             = 'application/json'
@@ -35,113 +36,45 @@ module OandaApiV20
         keep_alive:   30,
         idle_timeout: 10,
         warn_timeout: 2,
-        pool_size:    2
+        pool_size:    connection_pool_size
       }
-      persistent_connection_adapter_options.merge!(logger: RubyVM::Logger.new(STDOUT)) if @debug
+
+      persistent_connection_adapter_options.merge!(logger: ::Logger.new(STDOUT)) if debug
       Client.persistent_connection_adapter(persistent_connection_adapter_options)
     end
 
     def method_missing(name, *args, &block)
       case name
-      when :show, :create, :update, :cancel, :close
-        set_http_verb(name, last_action)
-        api = Api.new(api_attributes)
-
-        if api.respond_to?(last_action)
-          api_result = {}
-          set_last_api_request_at
-          govern_api_request_rate
-
-          begin
-            response = Http::Exceptions.wrap_and_check do
-              last_arguments.nil? || last_arguments.empty? ? api.send(last_action, &block) : api.send(last_action, *last_arguments, &block)
-            end
-          rescue Http::Exceptions::HttpException => e
-            raise OandaApiV20::RequestError, e.message
-          end
+      when *Api.api_methods
+        api_attributes = {
+          client:         self,
+          last_action:    name,
+          last_arguments: args
+        }
 
-          if response.body && !response.body.empty?
-            api_result.merge!(JSON.parse(response.body))
-            set_last_transaction_id(api_result['lastTransactionID']) if api_result['lastTransactionID']
-          end
-        end
+        api_attributes.merge!(account_id: args.first) if name == :account
+        api_attributes.merge!(instrument: args.first) if name == :instrument
 
-        api_result
-      when *api_methods
-        set_last_action_and_arguments(name, args)
-        set_account_id(args.first) if name == :account
-        set_instrument(args.first) if name == :instrument
-        self
+        Api.new(api_attributes)
       else
         super
       end
     end
 
-    private
-
-    attr_accessor :http_verb, :account_id, :instrument, :last_transaction_id, :last_action, :last_arguments, :last_api_request_at
-
-    def api_methods
-      Accounts.instance_methods + Instruments.instance_methods + Orders.instance_methods + Trades.instance_methods + Positions.instance_methods + Transactions.instance_methods + Pricing.instance_methods
-    end
-
     def govern_api_request_rate
       return unless last_api_request_at[0]
-      halt = 1 - (last_api_request_at[MAX_REQUESTS_PER_SECOND_ALLOWED - 1] - last_api_request_at[0])
+      halt = 1 - (last_api_request_at[max_requests_per_second - 1] - last_api_request_at[0])
       sleep halt if halt > 0
     end
 
-    def set_last_api_request_at
-      last_api_request_at.push(Time.now.utc).shift
-    end
-
-    def set_last_action_and_arguments(action, args)
-      set_last_action(action)
-      set_last_arguments(args)
-    end
-
-    def set_last_action(action)
-      self.last_action = action
-    end
-
-    def set_last_arguments(args)
-      self.last_arguments = args.nil? || args.empty? ? nil : args.flatten
-    end
-
-    def set_account_id(id)
-      self.account_id = id
-    end
-
-    def set_instrument(instrument)
-      self.instrument = instrument
-    end
-
-    def set_last_transaction_id(id)
-      self.last_transaction_id = id
-    end
-
-    def set_http_verb(action, last_action)
-      case action
-      when :show
-        self.http_verb = :get
-      when :update, :cancel, :close
-        [:configuration].include?(last_action) ? self.http_verb = :patch : self.http_verb = :put
-      when :create
-        self.http_verb = :post
-      else
-        self.http_verb = nil
+    def update_last_api_request_at
+      @mutex.synchronize do
+        last_api_request_at.push(Time.now.utc).shift
       end
     end
 
-    def api_attributes
-      {
-        http_verb: http_verb,
-        base_uri: base_uri,
-        headers: headers,
-        account_id: account_id,
-        instrument: instrument,
-        last_transaction_id: last_transaction_id
-      }
-    end
+    private
+
+    attr_accessor :last_api_request_at
   end
 end

data/lib/oanda_api_v20/exceptions.rb

@@ -1,3 +1,4 @@
 module OandaApiV20
+  class ApiError < RuntimeError; end
   class RequestError < RuntimeError; end
 end

data/lib/oanda_api_v20/instruments.rb

@@ -1,7 +1,7 @@
 # @see http://developer.oanda.com/rest-live-v20/instrument-ep/
 module OandaApiV20
   module Instruments
-    attr_accessor :instrument
+    attr_reader :instrument
 
     # GET /v3/instruments/:instrument/candles
     def candles(options = {})

data/lib/oanda_api_v20/version.rb

@@ -1,3 +1,3 @@
 module OandaApiV20
-  VERSION = '1.5.0'
+  VERSION = '2.0.0'
 end

data/oanda_api_v20.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec',   '~> 3.4'
   s.add_development_dependency 'webmock', '~> 2.1'
   s.add_development_dependency 'timecop', '~> 0.8'
-  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake',    '~> 10.5'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})

data/spec/oanda_api_v20/api_spec.rb

@@ -2,326 +2,505 @@ require 'spec_helper'
 
 describe OandaApiV20::Api do
   describe '#initialize' do
-    it 'sets the http_verb attribute when supplied' do
-      api = OandaApiV20::Api.new(http_verb: :post)
-      expect(api.http_verb).to eq(:post)
+    let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token') }
+
+    it 'sets the client attribute when supplied' do
+      api = OandaApiV20::Api.new(client: client)
+      expect(api.client).to eq(client)
+    end
+
+    it 'raises an OandaApiV20::ApiError exception when no client object was supplied' do
+      expect{ OandaApiV20::Api.new }.to raise_error(OandaApiV20::ApiError)
     end
 
     it 'sets the base_uri attribute when supplied' do
       url = 'https://api-fxpractice.oanda.com/v3'
-      api = OandaApiV20::Api.new(base_uri: url)
+      api = OandaApiV20::Api.new(client: client, base_uri: url)
       expect(api.base_uri).to eq(url)
     end
 
+    it 'sets the default base_uri attribute when not supplied' do
+      api = OandaApiV20::Api.new(client: client)
+      expect(api.base_uri).to eq('https://api-fxtrade.oanda.com/v3')
+    end
+
     it 'sets the headers attribute when supplied' do
       headers = { 'Content-Type' => 'application/json', 'Connection' => 'keep-alive', 'Keep-Alive' => '30' }
-      api = OandaApiV20::Api.new(headers: headers)
+      api = OandaApiV20::Api.new(client: client, headers: headers)
       expect(api.headers).to eq(headers)
     end
 
+    it 'sets the default headers attribute when not supplied' do
+      api = OandaApiV20::Api.new(client: client)
+      expect(api.headers).to eq({ 'Authorization' => 'Bearer my_access_token', 'X-Accept-Datetime-Format' => 'RFC3339', 'Content-Type' => 'application/json' })
+    end
+
     it 'sets the account_id attribute when supplied' do
       account_id = '100-100-100'
-      api = OandaApiV20::Api.new(account_id: account_id)
+      api = OandaApiV20::Api.new(client: client, account_id: account_id)
       expect(api.account_id).to eq(account_id)
     end
 
-    it 'sets the last_transaction_id attribute when supplied' do
-      last_transaction_id = '1'
-      api = OandaApiV20::Api.new(last_transaction_id: last_transaction_id)
-      expect(api.last_transaction_id).to eq(last_transaction_id)
-    end
-  end
-
-  describe '#public_methods' do
-    let!(:api)           { OandaApiV20::Api.new }
-    let(:public_methods) { [
-      :account, :accounts, :summary, :instruments, :changes, :configuration,
-      :order, :orders, :pending_orders,
-      :trade, :trades, :open_trades,
-      :position, :positions, :open_positions,
-      :transaction, :transactions, :transactions_id_range, :transactions_since_id,
-      :pricing
-    ] }
-
-    it 'responds to all public methods' do
-      public_methods.each do |public_method|
-        expect(api.respond_to?(public_method)).to be_truthy
-      end
-    end
-  end
-
-  describe 'constructs the correct API URL under' do
-    let!(:api) { OandaApiV20::Api.new(base_uri: 'https://api-fxtrade.oanda.com/v3', account_id: '100-100-100', headers: {}) }
-
-    before(:each) do
-      stub_request(:any, /https:\/\/api-fxtrade\.oanda\.com\/v3.*/)
-      api.http_verb = :get
+    it 'sets the instrument variable when supplied' do
+      instrument = 'EUR_USD'
+      api = OandaApiV20::Api.new(client: client, instrument: instrument)
+      expect(api.instance_variable_get(:@instrument)).to eq(instrument)
     end
 
-    context 'accounts for' do
-      it 'retrieving an account' do
-        api.account('100-100-100')
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100')).to have_been_made.once
-      end
-
-      it 'retrieving all accounts' do
-        api.accounts
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts')).to have_been_made.once
-      end
-
-      it 'retrieving a summary' do
-        api.summary
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/summary')).to have_been_made.once
-      end
-
-      it 'retrieving all instruments' do
-        api.instruments
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/instruments')).to have_been_made.once
-      end
-
-      it 'retrieving an instrument' do
-        api.instruments('EUR_USD')
-        options = { 'instruments' => 'EUR_USD' }
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/instruments').with(query: options)).to have_been_made.once
-      end
-
-      it 'retrieving all changes' do
-        api.last_transaction_id = '1'
-        api.changes
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/changes').with(query: { 'sinceTransactionID' => '1' })).to have_been_made.once
-      end
-
-      it 'retrieving all changes since a transaction id' do
-        options = {
-          'sinceTransactionID' => '1'
-        }
-        api.changes(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/changes').with(query: options)).to have_been_made.once
-      end
-
-      it 'updating a configuration' do
-        api.http_verb = :patch
-        options = { 'alias' => 'Timmy!' }
-        api.configuration(options)
-        expect(a_request(:patch, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/configuration').with(body: options.to_json))
-      end
+    it 'sets the last_action when supplied' do
+      api = OandaApiV20::Api.new(client: client, last_action: 'accounts')
+      expect(api.last_action).to eq('accounts')
     end
 
-    context 'instruments for' do
-      let!(:api) { OandaApiV20::Api.new(base_uri: 'https://api-fxtrade.oanda.com/v3', account_id: '100-100-100', instrument: 'EUR_USD', headers: {}) }
-
-      it 'retrieving candlestick data' do
-        options = { 'count' => '10' }
-        api.candles(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/instruments/EUR_USD/candles').with(query: options)).to have_been_made.once
-      end
+    it 'sets the last_arguments when supplied' do
+      api = OandaApiV20::Api.new(client: client, last_action: 'account', last_arguments: ['100-100-100'])
+      expect(api.last_action).to eq('account')
+      expect(api.last_arguments).to eq(['100-100-100'])
     end
+  end
 
-    context 'orders for' do
-      it 'retrieving an order' do
-        api.order('1')
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1')).to have_been_made.once
-      end
-
-      it 'creating an order' do
-        api.http_verb = :post
-        options = {
-          'order' => {
-            'units' => '100',
-            'instrument' => 'EUR_CAD',
-            'timeInForce' => 'FOK',
-            'type' => 'MARKET',
-            'positionFill' => 'DEFAULT'
+  describe '#method_missing' do
+    describe 'constructs the correct API URL under' do
+      let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token', base_uri: 'https://api-fxtrade.oanda.com/v3', headers: {}) }
+      let!(:api)    { OandaApiV20::Api.new(client: client, account_id: '100-100-100') }
+
+      before(:each) do
+        stub_request(:get, /https:\/\/api-fxtrade\.oanda\.com\/v3.*/)
+      end
+
+      context 'accounts for' do
+        it 'retrieving an account' do
+          api.account('100-100-100').show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100')).to have_been_made.once
+        end
+
+        it 'retrieving all accounts' do
+          api.accounts.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts')).to have_been_made.once
+        end
+
+        it 'retrieving a summary' do
+          api.summary.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/summary')).to have_been_made.once
+        end
+
+        it 'retrieving all instruments' do
+          api.instruments.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/instruments')).to have_been_made.once
+        end
+
+        it 'retrieving an instrument' do
+          api.instruments('EUR_USD').show
+          options = { 'instruments' => 'EUR_USD' }
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/instruments').with(query: options)).to have_been_made.once
+        end
+
+        it 'retrieving no changes' do
+          options = {}
+          api.changes(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/changes').with(query: { 'sinceTransactionID' => '' })).to have_been_made.once
+        end
+
+        it 'retrieving all changes since a transaction ID' do
+          options = { 'sinceTransactionID' => '1' }
+          api.changes(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/changes').with(query: options)).to have_been_made.once
+        end
+
+        it 'updating a configuration' do
+          options = { 'alias' => 'Timmy!' }
+          request = stub_request(:patch, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/configuration').with(body: options)
+          api.configuration(options).update
+          expect(request).to have_been_requested.once
+        end
+      end
+
+      context 'instruments for' do
+        let!(:api) { OandaApiV20::Api.new(client: client, account_id: '100-100-100', instrument: 'EUR_USD') }
+
+        it 'retrieving candlestick data' do
+          options = { 'count' => '10' }
+          api.candles(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/instruments/EUR_USD/candles').with(query: options)).to have_been_made.once
+        end
+      end
+
+      context 'orders for' do
+        it 'retrieving an order' do
+          api.order('1').show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1')).to have_been_made.once
+        end
+
+        it 'creating an order' do
+          options = {
+            'order' => {
+              'units' => '100',
+              'instrument' => 'EUR_CAD',
+              'timeInForce' => 'FOK',
+              'type' => 'MARKET',
+              'positionFill' => 'DEFAULT'
+            }
           }
-        }
-        api.order(options)
-        expect(a_request(:post, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders').with(body: options.to_json)).to have_been_made.once
-      end
+          request = stub_request(:post, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders').with(body: options)
+          api.order(options).create
+          expect(request).to have_been_requested.once
+        end
+
+        it 'updating an order' do
+          options = {
+            'order' => {
+              'timeInForce' => 'GTC',
+              'price' => '1.7000',
+              'type' => 'TAKE_PROFIT',
+              'tradeID' => '1'
+            }
+          }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1').with(body: options)
+          api.order('1', options).update
+          expect(request).to have_been_requested.once
+        end
+
+        it 'updating an order client extensions' do
+          options = {
+            'clientExtensions' => {
+              'comment' => 'New comment for my limit order'
+            }
+          }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1/clientExtensions').with(body: options)
+          api.order('1', options).update
+          expect(request).to have_been_requested.once
+        end
+
+        it 'cancelling an order' do
+          request = stub_request(:put,'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1/cancel')
+          api.order('1').cancel
+          expect(request).to have_been_requested.once
+        end
+
+        it 'retrieving all orders' do
+          api.orders.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders')).to have_been_made.once
+        end
+
+        it 'retrieving all orders' do
+          options = { 'instrument' => 'USD_CAD' }
+          api.orders(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders').with(query: options)).to have_been_made.once
+        end
+
+        it 'retrieving all pending orders' do
+          api.pending_orders.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/pendingOrders')).to have_been_made.once
+        end
+      end
+
+      context 'trades for' do
+        it 'retrieving a trade' do
+          api.trade('1').show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1')).to have_been_made.once
+        end
+
+        it 'updating a trade' do
+          options = {
+            'takeProfit' => {
+              'timeInForce' => 'GTC',
+              'price' => '0.5'
+            },
+            'stopLoss' => {
+              'timeInForce' => 'GTC',
+              'price' => '2.5'
+            }
+          }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/orders').with(body: options)
+          api.trade('1', options).update
+          expect(request).to have_been_requested.once
+        end
+
+        it 'updating a trade client extensions' do
+          options = {
+            'clientExtensions' => {
+              'comment' => 'This is a USD/CAD trade',
+              'tag' => 'trade tag',
+              'id' => 'my_usd_cad_trade'
+            }
+          }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/clientExtensions').with(body: options)
+          api.trade('1', options).update
+          expect(request).to have_been_requested.once
+        end
+
+        it 'closing a trade' do
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/close')
+          api.trade('1').close
+          expect(request).to have_been_requested.once
+        end
+
+        it 'closing a trade partially' do
+          options = { 'units' => '10' }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/close')
+          api.trade('1', options).close
+          expect(request).to have_been_requested.once
+        end
+
+        it 'retrieving all trades' do
+          options = { 'instrument' => 'USD_CAD' }
+          api.trades(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades').with(query: options)).to have_been_made.once
+        end
+
+        it 'retrieving all open trades' do
+          api.open_trades.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/openTrades')).to have_been_made.once
+        end
+      end
+
+      context 'positions for' do
+        it 'retrieving a position' do
+          api.position('EUR_USD').show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_USD')).to have_been_made.once
+        end
+
+        it 'retrieving all positions' do
+          api.positions.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions')).to have_been_made.once
+        end
+
+        it 'retrieving all open positions' do
+          api.open_positions.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/openPositions')).to have_been_made.once
+        end
+
+        it 'closing a position' do
+          options = { 'longUnits' => 'ALL' }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_CAD/close').with(body: options)
+          api.position('EUR_CAD', options).close
+          expect(request).to have_been_requested.once
+        end
+
+        it 'closing a position partially' do
+          options = { 'longUnits' => '99' }
+          request = stub_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_CAD/close').with(body: options)
+          api.position('EUR_CAD', options).close
+          expect(request).to have_been_requested.once
+        end
+      end
+
+      context 'transactions for' do
+        it 'retrieving a transaction' do
+          api.transaction('1').show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/1')).to have_been_made.once
+        end
+
+        it 'retrieving all transactions' do
+          api.transactions.show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions')).to have_been_made.once
+        end
+
+        it 'retrieving all transactions in date range' do
+          options = {
+            'from' => '2016-08-01T02:00:00Z',
+            'to' => '2016-08-15T02:00:00Z'
+          }
+          api.transactions(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions').with(query: options)).to have_been_made.once
+        end
+
+        it 'retrieving all transactions in an ID range' do
+          options = {
+            'from' => '6409',
+            'to' => '6412'
+          }
+          api.transactions_id_range(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/idrange').with(query: options)).to have_been_made.once
+        end
 
-      it 'updating an order' do
-        api.http_verb = :put
-        options = {
-          'order' => {
-            'timeInForce' => 'GTC',
-            'price' => '1.7000',
-            'type' => 'TAKE_PROFIT',
-            'tradeID' => '1'
+        it 'retrieving all transactions since an ID' do
+          options = {
+            'id' => '6411'
           }
-        }
-        api.order('1', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1').with(body: options.to_json)).to have_been_made.once
+          api.transactions_since_id(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/sinceid').with(query: options)).to have_been_made.once
+        end
       end
 
-      it 'updating an order client extensions' do
-        api.http_verb = :put
-        options = {
-          'clientExtensions' => {
-            'comment' => 'New comment for my limit order'
+      context 'pricing for' do
+        it 'retrieving all pricing' do
+          options = {
+            'instruments' => 'EUR_USD,USD_CAD'
           }
-        }
-        api.order('1', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1/clientExtensions').with(body: options.to_json)).to have_been_made.once
+          api.pricing(options).show
+          expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/pricing').with(query: options)).to have_been_made.once
+        end
       end
+    end
 
-      it 'cancelling an order' do
-        api.http_verb = :put
-        api.order('1')
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders/1/cancel')).to have_been_made.once
-      end
+    describe 'network' do
+      let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token', base_uri: 'https://api-fxtrade.oanda.com/v3', headers: {}) }
+      let!(:api)    { OandaApiV20::Api.new(client: client) }
 
-      it 'retrieving all orders' do
-        api.orders
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders')).to have_been_made.once
-      end
+      let(:response_account)  { '{"account":{"id":"100-100-100","NAV":"100000.0000","balance":"100000.0000","lastTransactionID":"99","orders":[],"positions":[],"trades":[],"pendingOrderCount":0},"lastTransactionID":"99"}' }
+      let!(:request_account)  { stub_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100').to_return(status: 200, body: response_account, headers: {}) }
 
-      it 'retrieving all orders' do
-        options = { 'instrument' => 'USD_CAD' }
-        api.orders(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders').with(query: options)).to have_been_made.once
-      end
+      let(:response_accounts) { '{"accounts":[{"id":"100-100-100","tags":[]}]}' }
+      let!(:request_accounts) { stub_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts').to_return(status: 200, body: response_accounts, headers: {}) }
 
-      it 'retrieving all pending orders' do
-        api.pending_orders
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/pendingOrders')).to have_been_made.once
+      it 'makes a request to Oanda API' do
+        api.accounts.show
+        expect(request_accounts).to have_been_requested
+        expect(request_accounts).to have_been_requested.at_most_once
       end
-    end
 
-    context 'trades for' do
-      it 'retrieving a trade' do
-        api.trade('1')
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1')).to have_been_made.once
+      it 'returns the response from Oanda API' do
+        expect(api.accounts.show).to eq(JSON.parse(response_accounts))
+        expect(api.account('100-100-100').show).to eq(JSON.parse(response_account))
       end
+    end
 
-      it 'updating a trade' do
-        api.http_verb = :put
-        options = {
-          'takeProfit' => {
-            'timeInForce' => 'GTC',
-            'price' => '0.5'
-          },
-          'stopLoss' => {
-            'timeInForce' => 'GTC',
-            'price' => '2.5'
+    describe 'sets the correct HTTP verb' do
+      let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token', base_uri: 'https://api-fxtrade.oanda.com/v3', headers: {}) }
+      let!(:api)    { OandaApiV20::Api.new(client: client, account_id: '100-100-100') }
+
+      context 'for GET' do
+        let!(:request) { stub_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts') }
+
+        it 'uses the correct HTTP verb' do
+          api.accounts.show
+          expect(request).to have_been_requested.once
+        end
+
+        it 'clears the HTTP verb attribute after use' do
+          api.accounts.show
+          expect(api.send(:http_verb)).to be_nil
+        end
+      end
+
+      context 'for POST' do
+        let!(:options) {
+          {
+            'order' => {
+              'units' => '100',
+              'instrument' => 'EUR_CAD',
+              'timeInForce' => 'FOK',
+              'type' => 'MARKET',
+              'positionFill' => 'DEFAULT'
+            }
           }
         }
-        api.trade('1', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/orders').with(body: options.to_json)).to have_been_made.once
-      end
+        let!(:request) { stub_request(:post, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/orders').with(body: options) }
 
-      it 'updating a trade client extensions' do
-        api.http_verb = :put
-        options = {
-          'clientExtensions' => {
-            'comment' => 'This is a USD/CAD trade',
-            'tag' => 'trade tag',
-            'id' => 'my_usd_cad_trade'
-          }
-        }
-        api.trade('1', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/clientExtensions').with(body: options.to_json)).to have_been_made.once
-      end
+        it 'uses the correct HTTP verb' do
+          api.order(options).create
+          expect(request).to have_been_requested.once
+        end
 
-      it 'closing a trade' do
-        api.http_verb = :put
-        api.trade('1')
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/close')).to have_been_made.once
+        it 'clears the HTTP verb attribute after use' do
+          api.order(options).create
+          expect(api.send(:http_verb)).to be_nil
+        end
       end
 
-      it 'closing a trade partially' do
-        api.http_verb = :put
-        options = { 'units' => '10' }
-        api.trade('1', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades/1/close')).to have_been_made.once
-      end
+      context 'for PATCH' do
+        let!(:options) { { 'alias' => 'Timmy!' } }
+        let!(:request) { stub_request(:patch, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/configuration').with(body: options) }
 
-      it 'retrieving all trades' do
-        options = { 'instrument' => 'USD_CAD' }
-        api.trades(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/trades').with(query: options)).to have_been_made.once
-      end
+        it 'uses the correct HTTP verb' do
+          api.configuration(options).update
+          expect(request).to have_been_requested.once
+        end
 
-      it 'retrieving all open trades' do
-        api.open_trades
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/openTrades')).to have_been_made.once
+        it 'clears the HTTP verb attribute after use' do
+          api.configuration(options).update
+          expect(api.send(:http_verb)).to be_nil
+        end
       end
     end
+  end
 
-    context 'positions for' do
-      it 'retrieving a position' do
-        api.position('EUR_USD')
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_USD')).to have_been_made.once
-      end
-
-      it 'retrieving all positions' do
-        api.positions
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions')).to have_been_made.once
-      end
-
-      it 'retrieving all open positions' do
-        api.open_positions
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/openPositions')).to have_been_made.once
-      end
-
-      it 'closing a position' do
-        api.http_verb = :put
-        options = { 'longUnits' => 'ALL' }
-        api.position('EUR_CAD', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_CAD/close').with(body: options.to_json)).to have_been_made.once
-      end
+  describe 'public methods' do
+    let!(:client)        { OandaApiV20::Client.new(access_token: 'my_access_token') }
+    let!(:api)           { OandaApiV20::Api.new(client: client) }
+    let(:public_methods) { [
+      :account, :accounts, :summary, :instruments, :changes, :configuration,
+      :order, :orders, :pending_orders,
+      :trade, :trades, :open_trades,
+      :position, :positions, :open_positions,
+      :transaction, :transactions, :transactions_id_range, :transactions_since_id,
+      :pricing,
+      :candles
+    ] }
 
-      it 'closing a position partially' do
-        api.http_verb = :put
-        options = { 'longUnits' => '99' }
-        api.position('EUR_CAD', options)
-        expect(a_request(:put, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/positions/EUR_CAD/close').with(body: options.to_json)).to have_been_made.once
+    it 'responds to all public methods' do
+      public_methods.each do |public_method|
+        expect(api.respond_to?(public_method)).to be_truthy
       end
     end
 
-    context 'transactions for' do
-      it 'retrieving a transaction' do
-        api.transaction('1')
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/1')).to have_been_made.once
-      end
+    it 'returns an OandaApiV20::Api instance when calling any of the public methods' do
+      expect(api.accounts).to be_an_instance_of(OandaApiV20::Api)
+    end
 
-      it 'retrieving all transactions' do
-        api.transactions
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions')).to have_been_made.once
-      end
+    it 'makes a request to Oanda API when calling any of the action methods' do
+      request = stub_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts')
+      api.accounts.show
+      expect(request).to have_been_requested.once
+    end
+  end
 
-      it 'retrieving all transactions in date range' do
-        options = {
-          'from' => '2016-08-01T02:00:00Z',
-          'to' => '2016-08-15T02:00:00Z'
-        }
-        api.transactions(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions').with(query: options)).to have_been_made.once
+  describe 'private methods' do
+    describe '#set_http_verb' do
+      let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token', base_uri: 'https://api-fxtrade.oanda.com/v3', headers: {}) }
+      let!(:api)    { OandaApiV20::Api.new(client: client) }
+
+      describe 'sets the correct HTTP verb' do
+        it 'for GET' do
+          api.send(:set_http_verb, :show, nil)
+          expect(api.send(:http_verb)).to eq(:get)
+        end
+
+        it 'for POST' do
+          api.send(:set_http_verb, :create, nil)
+          expect(api.send(:http_verb)).to eq(:post)
+        end
+
+        it 'for PUT' do
+          api.send(:set_http_verb, :update, nil)
+          expect(api.send(:http_verb)).to eq(:put)
+        end
+
+        it 'for PUT' do
+          api.send(:set_http_verb, :cancel, nil)
+          expect(api.send(:http_verb)).to eq(:put)
+        end
+
+        it 'for PUT' do
+          api.send(:set_http_verb, :close, nil)
+          expect(api.send(:http_verb)).to eq(:put)
+        end
+
+        it 'for PATCH' do
+          api.send(:set_http_verb, :update, :configuration)
+          expect(api.send(:http_verb)).to eq(:patch)
+        end
+
+        it 'for POST' do
+          api.send(:set_http_verb, :create, nil)
+          expect(api.send(:http_verb)).to eq(:post)
+        end
       end
+    end
 
-      it 'retrieving all transactions in an id range' do
-        options = {
-          'from' => '6409',
-          'to' => '6412'
-        }
-        api.transactions_id_range(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/idrange').with(query: options)).to have_been_made.once
-      end
+    describe '#set_last_action_and_arguments' do
+      let!(:client) { OandaApiV20::Client.new(access_token: 'my_access_token', base_uri: 'https://api-fxtrade.oanda.com/v3', headers: {}) }
+      let!(:api)    { OandaApiV20::Api.new(client: client) }
 
-      it 'retrieving all transactions since an id' do
-        options = {
-          'id' => '6411'
-        }
-        api.transactions_since_id(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/transactions/sinceid').with(query: options)).to have_been_made.once
+      it 'sets the last_action attribute' do
+        api.send(:set_last_action_and_arguments, :accounts)
+        expect(api.send(:last_action)).to eq(:accounts)
       end
-    end
 
-    context 'pricing for' do
-      it 'retrieving all pricing' do
-        options = {
-          'instruments' => 'EUR_USD,USD_CAD'
-        }
-        api.pricing(options)
-        expect(a_request(:get, 'https://api-fxtrade.oanda.com/v3/accounts/100-100-100/pricing').with(query: options)).to have_been_made.once
+      it 'sets the last_arguments attribute' do
+        api.send(:set_last_action_and_arguments, :account, '100-100-100')
+        expect(api.send(:last_arguments)).to eq(['100-100-100'])
       end
     end
   end