oanda_api 0.8.1 → 0.8.3

data/spec/oanda_api/examples/positions_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Resource::Position" do
+  let(:account) { ClientHelper.account }
+
+  it "gets all open positions", :vcr do
+    VCR.use_cassette("account(id).positions.get") do
+      ClientHelper.create_trade
+      positions = account.positions.get
+      expect(positions.first).to be_an OandaAPI::Resource::Position
+    end
+  end
+
+  it "gets the position for an instrument", :vcr do
+    VCR.use_cassette("account(id).positions(instrument).get") do
+      ClientHelper.create_trade(instrument: "USD_JPY")
+      position = account.positions("USD_JPY").get
+      expect(position).to be_an OandaAPI::Resource::Position
+    end
+  end
+
+  it "closes an existing position", :vcr do
+    VCR.use_cassette("account(id).positions(instrument).close") do
+      ClientHelper.create_trade(instrument: "USD_JPY")
+
+      # Verify we have an open position.
+      position = account.position("USD_JPY").get
+      expect(position).to be_an OandaAPI::Resource::Position
+
+      account.position("USD_JPY").close
+
+      # Verify that the position has been closed.
+      positions = account.positions.get
+      expect(positions.map(&:instrument)).to_not include "USD_JPY"
+    end
+  end
+end

data/spec/oanda_api/examples/rates_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Resource" do
+  let(:client) { ClientHelper.client }
+
+  describe "Instrument" do
+    it "gets all instruments", :vcr do
+      VCR.use_cassette("instruments.get") do
+        instruments = client.instruments.get
+        expect(instruments.first).to be_an OandaAPI::Resource::Instrument
+      end
+    end
+
+    it "gets a filtered list of instruments", :vcr do
+      VCR.use_cassette("instruments(options).get") do
+        instruments = client.instruments(instruments: %w(EUR_USD EUR_CAD),
+                                              fields: %w(pip precision))
+                            .get
+        expect(instruments.first).to be_an OandaAPI::Resource::Instrument
+      end
+    end
+  end
+
+  describe "Price" do
+    it "gets a filtered list of prices", :vcr do
+      VCR.use_cassette("prices(options).get") do
+        prices = client.prices(instruments: %w(EUR_USD EUR_CAD)).get
+        expect(prices.first).to be_an OandaAPI::Resource::Price
+      end
+    end
+  end
+
+  describe "Candle" do
+    it "gets candles for an instrument", :vcr do
+      VCR.use_cassette("candles(options).get") do
+        candles = client.candles(instrument: "EUR_USD",
+                                granularity: "M1",
+                                      count: 1,
+                              candle_format: "midpoint")
+                        .get
+        expect(candles.first).to be_an OandaAPI::Resource::Candle
+      end
+    end
+  end
+end

data/spec/oanda_api/examples/trades_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Resource::Trade" do
+  let(:account) { ClientHelper.account }
+
+  it "gets a list of trades", :vcr do
+    VCR.use_cassette("account(id).trades.get") do
+      ClientHelper.create_trade
+      trades = account.trades.get
+      expect(trades.first).to be_an OandaAPI::Resource::Trade
+    end
+  end
+
+  it "gets a filtered list of trades", :vcr do
+    VCR.use_cassette("account(id).trades(filter).get") do
+      ClientHelper.create_trade(instrument: "USD_JPY")
+      trades = account.trades(instrument: "USD_JPY").get
+      expect(trades.first).to be_an OandaAPI::Resource::Trade
+    end
+  end
+
+  it "gets information on a specific trade", :vcr do
+    VCR.use_cassette("account(id).trade(id).get") do
+      trade_id = ClientHelper.create_trade.trade_opened.id
+      trade = account.trade(trade_id).get
+      expect(trade).to be_an OandaAPI::Resource::Trade
+    end
+  end
+
+  it "modifies an open trade " do
+    VCR.use_cassette("account(id).trade(options).modify") do
+      order = ClientHelper.create_trade
+      modified_order =
+        account.trade(id: order.trade_opened.id, take_profit: order.price + 2.0)
+               .update
+      expect(modified_order).to be_an OandaAPI::Resource::Trade
+    end
+  end
+
+  it "closes an open trade" do
+    VCR.use_cassette("account(id).trade(id).close") do
+      ClientHelper.create_trade(instrument: "USD_JPY").trade_opened.id
+
+      # Get the oldest open trade for USD_JPY, so we can close that trade.
+      oldest_trade =
+        account.trades(instrument: "USD_JPY")
+               .get
+               .min_by(&:id)
+
+      closed_trade = account.trade(oldest_trade.id).close
+      expect(closed_trade).to be_an OandaAPI::Resource::Trade
+
+      open_trades = account.trades.get
+      expect(open_trades.map(&:id)).to_not include oldest_trade.id
+    end
+  end
+end

data/spec/oanda_api/examples/transactions_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Transaction" do
+  let(:account) { ClientHelper.account }
+
+  it "gets transaction history" do
+    VCR.use_cassette("account(id).transactions(options).get") do
+      ClientHelper.create_trade(instrument: "USD_JPY")
+      transactions = account.transactions(instrument: "USD_JPY").get
+      expect(transactions.first).to be_an OandaAPI::Resource::Transaction
+    end
+  end
+
+  it "gets information for a specific transaction" do
+    VCR.use_cassette("account(id).transaction(id).get") do
+      ClientHelper.create_trade(instrument: "USD_JPY")
+      id = account.transactions(instrument: "USD_JPY").get.first.id
+      transaction = account.transaction(id).get
+      expect(transaction).to be_an OandaAPI::Resource::Transaction
+      expect(transaction.trade_opened).to be_a OandaAPI::Resource::Transaction::TradeOpened
+    end
+  end
+end

data/spec/oanda_api/resource_collection_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe "OandaAPI::ResourceCollection" do
+  let(:resource_descriptor) { OandaAPI::Client::ResourceDescriptor.new "/candles", :get }
+
+  describe "#initialize" do
+    context "with a collection attribute matching the one expected by the resource descriptor" do
+      let(:resource_collection) { OandaAPI::ResourceCollection.new({ candles: [{ volume: 10 }] }, resource_descriptor) }
+
+      it "returns a ResourceCollection" do
+        expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+      end
+
+      it "is Enumerable" do
+        expect(resource_collection).to be_an Enumerable
+      end
+
+      it "contains elements of the expected resource" do
+        expect(resource_collection.first).to be_an OandaAPI::Resource::Candle
+      end
+
+      it "contains initialized resource elements" do
+        expect(resource_collection.first.volume).to eq 10
+      end
+
+      describe "when the collection element is empty" do
+        let(:resource_collection) { OandaAPI::ResourceCollection.new({ candles: [] }, resource_descriptor) }
+        it "returns a ResourceCollection" do
+           expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+        end
+        it "is an empty collection" do
+          expect(resource_collection.empty?).to be true
+        end
+      end
+
+      describe "with extra attributes" do
+        let(:resource_collection) { OandaAPI::ResourceCollection.new({ candles: [], extra: "I'm special" }, resource_descriptor) }
+
+        it "returns a ResourceCollection" do
+          expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+        end
+
+        it "has an accessor for the extra attributes" do
+          expect(resource_collection.extra).to eq "I'm special"
+        end
+      end
+    end
+
+    context "without the collection attribute expected by the resource descriptor " do
+      let(:resource_collection) { OandaAPI::ResourceCollection.new({}, resource_descriptor) }
+
+      it "returns a ResourceCollection" do
+        expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+      end
+
+      it "is Enumerable" do
+        expect(resource_collection).to be_an Enumerable
+      end
+
+      it "is an empty collection" do
+        expect(resource_collection.empty?).to be true
+      end
+
+      describe "with extra attributes" do
+        let(:resource_collection) { OandaAPI::ResourceCollection.new({ extra: "I'm special" }, resource_descriptor) }
+
+        it "returns a ResourceCollection" do
+          expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+        end
+
+        it "has an accessor for the extra attribute" do
+          expect(resource_collection.extra).to eq "I'm special"
+        end
+      end
+    end
+
+    context "with nil" do
+      let(:resource_collection) { OandaAPI::ResourceCollection.new(nil, resource_descriptor) }
+
+      it "returns a ResourceCollection" do
+        expect(resource_collection).to be_an(OandaAPI::ResourceCollection)
+      end
+
+      it "is Enumerable" do
+        expect(resource_collection).to be_an Enumerable
+      end
+
+      it "is an empty collection" do
+        expect(resource_collection.empty?).to be true
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    let(:resource_collection) { OandaAPI::ResourceCollection.new({ candles: [], extra: "I'm special" }, resource_descriptor) }
+
+    it "responds to collection methods" do
+      expect(resource_collection.respond_to?(:shuffle)).to be true
+    end
+
+    it "responds to dynamic accessors for extra attributes" do
+      expect(resource_collection.respond_to?(:extra)).to be true
+    end
+
+    it "responds to concrete accessors" do
+      expect(resource_collection.respond_to?(:location)).to be true
+    end
+  end
+end

data/spec/oanda_api/utils/utils_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe "OandaAPI::Utils" do
+  describe ".camelize" do
+    it "puts humps on a string starting out low" do
+      expect(OandaAPI::Utils.camelize("ruby_is_awesome")).to eq("rubyIsAwesome")
+    end
+
+    it "works with already camelized" do
+      expect(OandaAPI::Utils.camelize("imACamel")).to eq("imACamel")
+    end
+
+    it "works with numbers" do
+      expect(OandaAPI::Utils.camelize("a_number_1_concern")).to eq("aNumber1Concern")
+    end
+
+    it "works with symbols" do
+      expect(OandaAPI::Utils.camelize(:ugly_symbol)).to eq("uglySymbol")
+    end
+
+    it "turns nil to empty" do
+      expect(OandaAPI::Utils.camelize(nil)).to eq("")
+    end
+
+    it "ignores empty" do
+      expect(OandaAPI::Utils.camelize("")).to eq("")
+    end
+  end
+
+  describe ".pluralize" do
+    it "naively adds an s to the end of strings" do
+      expect(OandaAPI::Utils.pluralize("thing")).to eq("things")
+    end
+
+    it "doesn't add an s if it's already there" do
+      expect(OandaAPI::Utils.pluralize("things")).to eq("things")
+    end
+
+    it "turns nil to empty" do
+      expect(OandaAPI::Utils.pluralize(nil)).to eq("")
+    end
+
+    it "ignores empty" do
+      expect(OandaAPI::Utils.pluralize("")).to eq("")
+    end
+  end
+
+  describe ".singularize" do
+    it "naively removes trailing s" do
+      expect(OandaAPI::Utils.singularize("things")).to eq("thing")
+    end
+
+    it "turns nil to empty" do
+      expect(OandaAPI::Utils.singularize(nil)).to eq("")
+    end
+
+    it "ignores empty" do
+      expect(OandaAPI::Utils.singularize("")).to eq("")
+    end
+  end
+
+  describe ".rubyize_keys" do
+    it "converts all keys in a hash into snake_cased_symbols, " do
+      hash            = { "a" => "a", "b" => [{ "a" => "a" }], :c => "c", "camelCase" => "" }
+      symbolized_hash = { :a  => "a", :b  => [{ :a  => "a" }], :c => "c", :camel_case => "" }
+      expect(OandaAPI::Utils.rubyize_keys(hash)).to eq(symbolized_hash)
+    end
+  end
+
+  describe ".underscore" do
+    it "converts a string to snake_case" do
+      expect(OandaAPI::Utils.underscore("camelCase-dashedTLA")).to eq("camel_case_dashed_tla")
+    end
+
+    it "turns nil to empty" do
+      expect(OandaAPI::Utils.underscore(nil)).to eq("")
+    end
+
+    it "ignores empty" do
+      expect(OandaAPI::Utils.underscore("")).to eq("")
+    end
+  end
+
+  describe ".transform_hash_keys" do
+    it "yields every key in a nested hash" do
+      hash = { "a" => "a", :b => [{ :c => "c" }], :d => "d" }
+      expect { |b| OandaAPI::Utils.transform_hash_keys(hash, &b) }.to yield_successive_args("a", :b, :c, :d)
+    end
+
+    it "replaces hash keys with the yielded return values" do
+      hash             = { "a" => "a", "b" => [{ "c" => "c" }], "d" => "d" }
+      transformed_hash = { :a  => "a", :b  => [{ :c  => "c" }], :d  => "d" }
+      expect(OandaAPI::Utils.transform_hash_keys(hash) { |key| key.to_sym }).to eq(transformed_hash)
+    end
+  end
+
+  describe ".transform_hash_values" do
+    it "yields every scalar key,value pair in a nested hash" do
+      hash = { "a" => "a", :b => [{ :c => "c" }], :d => "d" }
+      expect { |b| OandaAPI::Utils.transform_hash_values(hash, &b) }.to yield_successive_args(["a", "a"], [:c, "c"], [:d, "d"])
+    end
+
+    it "replaces scalar hash element values with the yielded return values" do
+      hash             = { :a => "a", :b => [{ :c => "c" }], :d => "d" }
+      transformed_hash = { :a => :a,  :b => [{ :c => :c  }], :d => :d  }
+      expect(OandaAPI::Utils.transform_hash_values(hash) { |_key, value| value.to_sym }).to eq(transformed_hash)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oanda_api'
+
+RSpec.configure do |c|
+  c.before(:suite) do
+    # Disable request throttling because all examples are stubbed with VCR and webmock.
+    OandaAPI.configure { |config| config.use_request_throttling = false }
+  end
+end

data/spec/support/client_helper.rb

@@ -0,0 +1,60 @@
+require 'support/vcr'
+module ClientHelper
+  # Returns a sandbox client
+  def self.client
+    VCR.use_cassette("sandbox_client") do
+      client = OandaAPI::Client::UsernameClient.new "_"
+      new_account = client.account.create
+      OandaAPI::Client::UsernameClient.new new_account.username
+    end
+  end
+
+  # Returns the account namespace for the client
+  def self.account
+    VCR.use_cassette("sandbox_client_account") do
+      account_id = ClientHelper.client.accounts.get.first.account_id
+      ClientHelper.client.account(account_id)
+    end
+  end
+
+  # Creates a trade
+  def self.create_trade(instrument: "USD_JPY",
+                              type: "market",
+                              side: "buy",
+                             units: 10_000,
+                             price: nil,
+                            expiry: (Time.now + 3600).utc.to_datetime.rfc3339)
+    opts =
+      case type
+      when "market"
+        { instrument: instrument,
+                type: type,
+                side: side,
+               units: units }
+      when "limit"
+        { instrument: instrument,
+                type: type,
+                side: side,
+               units: units,
+               price: price,
+              expiry: expiry }
+      else
+        fail ArgumentError, "invalid order type: #{type}"
+      end
+    account.order(opts).create
+  end
+
+  singleton_class.send(:alias_method, :create_order, :create_trade)
+
+  # Returns a lightweight instrument object
+  def self.instrument(instrument)
+    VCR.use_cassette("sandbox_instrument_#{instrument}") do
+      price = ClientHelper.client.prices(instruments: instrument).get.first
+      o = Struct.new(:instrument, :bid, :ask).new
+      o.instrument = instrument
+      o.bid = price.bid
+      o.ask = price.ask
+      o
+    end
+  end
+end