oanda_api 0.8.1 → 0.8.3

data/spec/oanda_api/client/client_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'uri'
+require 'webmock/rspec'
+
+describe "OandaAPI::Client" do
+  describe ".query_string_normalizer" do
+    let(:query_string_normalizer) { OandaAPI::Client.default_options[:query_string_normalizer] }
+
+    it "responds to :call" do
+      expect(query_string_normalizer.respond_to? :call).to be true
+    end
+
+    it "converts a hash to a query params string with camelized keys" do
+      hash = { ruby_key1: 1 }
+      expect(query_string_normalizer.call(hash)).to eq("rubyKey1=1")
+    end
+
+    it "sorts query parameters alphabetically" do
+      hash = { ruby_key: 1, a_b_c: 1 }
+      expect(query_string_normalizer.call(hash)).to eq("aBC=1&rubyKey=1")
+    end
+
+    it "URI encodes the parameter values" do
+      hash = { key: "a,b,c" }
+      expect(query_string_normalizer.call(hash)).to eq("key=a%2Cb%2Cc")
+    end
+
+    it "converts array values into comma-delimited strings" do
+      hash = { key: %w(a b c) }
+      expect(query_string_normalizer.call(hash)).to eq("key=a%2Cb%2Cc")
+    end
+
+    it "works with nil values" do
+      hash = { camel_key: nil }
+      expect(query_string_normalizer.call(hash)).to eq("camelKey")
+    end
+  end
+
+  describe ".throttle_request_rate" do
+    before(:all) do
+      @throttle_setting = OandaAPI.configuration.use_request_throttling
+    end
+    after(:all) do
+      OandaAPI.configuration.use_request_throttling = @throttle_setting
+    end
+
+    context "without request throttling" do
+      it "does not throttle" do
+        OandaAPI.configuration.use_request_throttling = false
+        last_throttled_at = OandaAPI::Client.last_throttled_at
+
+        (OandaAPI.configuration.max_requests_per_second + 2).times do
+          OandaAPI::Client.throttle_request_rate
+        end
+        expect(OandaAPI::Client.last_throttled_at).to eq last_throttled_at
+      end
+    end
+
+    context "with request throttling" do
+      it "limits the number of requests per second" do
+        OandaAPI.configuration.use_request_throttling = true
+        before_throttled_at = Time.now
+
+        (OandaAPI.configuration.max_requests_per_second + 2).times do
+          OandaAPI::Client.throttle_request_rate
+        end
+        expect(OandaAPI::Client.last_throttled_at).to be > before_throttled_at
+      end
+    end
+  end
+
+  describe "#api_uri" do
+    let(:client) { Struct.new(:domain) { include OandaAPI::Client }.new }
+    it "is domain specific" do
+      uris = {}
+      OandaAPI::DOMAINS.each do |domain|
+        client.domain = domain
+        uris[client.api_uri("/path")] = domain
+      end
+      expect(uris.size).to eq(3)
+    end
+
+    it "is an absolute URI" do
+      OandaAPI::DOMAINS.each do |domain|
+        client.domain = domain
+        uri = URI.parse client.api_uri("/path")
+        expect(uri.absolute?).to be true
+      end
+    end
+  end
+
+  describe "#execute_request" do
+    let(:client) { OandaAPI::Client::UsernameClient.new "spongebob" }
+
+    it "returns a response for a successful request" do
+      stub_request(:get, "http://api-sandbox.oanda.com/v1/accounts?username=spongebob")
+        .to_return(status: 200, body: "{\"accounts\" : []}", headers: { "content-type" => "application/json" })
+      expect(client.execute_request(:get, "/accounts")).to be_an OandaAPI::ResourceCollection
+    end
+
+    it "raises OandaAPI::RequestError for an invalid request" do
+      stub_request(:get, "http://api-sandbox.oanda.com/v1/accounts/a_bad_request?username=spongebob")
+        .to_return(status:  [404, "Something bad happened (but we still love you)."])
+      expect { client.execute_request :get, "/accounts/a_bad_request" }.to raise_error(OandaAPI::RequestError)
+    end
+  end
+end

data/spec/oanda_api/client/namespace_proxy_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "OandaAPI::Client::NamespaceProxy" do
+  let(:client) { OandaAPI::Client::UsernameClient.new("spongebob") }
+  let(:namespace_proxy) { OandaAPI::Client::NamespaceProxy.new client, "account" }
+
+  describe "#initialize" do
+    it "raises ArgumentError unless an OandaAPI::Client is passed" do
+      expect { OandaAPI::Client::NamespaceProxy.new nil, "account" }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError unless a non-empty namespace string is passed" do
+      expect { OandaAPI::Client::NamespaceProxy.new client, "" }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/oanda_api/client/resource_descriptor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "OandaAPI::Client::ResourceDescriptor" do
+  describe "#initialize" do
+    let(:resource_descriptor) { OandaAPI::Client::ResourceDescriptor.new "/accounts", :get }
+    it "sets path" do
+      expect(resource_descriptor.path).to eq("/accounts")
+    end
+  end
+
+  context "when the path ends with a known resource" do
+    let(:resource_descriptor) { OandaAPI::Client::ResourceDescriptor.new "/account/123/orders", :get }
+
+    describe "#resource_klass" do
+      it "is the requested resource class" do
+        expect(resource_descriptor.resource_klass).to be(OandaAPI::Resource::Order)
+      end
+    end
+  end
+
+  describe "#is_collection?" do
+    it "is true for GET requests without a resource id" do
+      resource_descriptor = OandaAPI::Client::ResourceDescriptor.new "/account/123/orders", :get
+      expect(resource_descriptor.is_collection?).to be true
+    end
+
+    it "is false for GET requests with a resource id" do
+      resource_descriptor = OandaAPI::Client::ResourceDescriptor.new "/account/123", :get
+      expect(resource_descriptor.is_collection?).to be false
+    end
+
+    it "is false for non-GET requests" do
+      [:delete, :patch, :post].each do |verb|
+        resource_descriptor = OandaAPI::Client::ResourceDescriptor.new "/account", verb
+        expect(resource_descriptor.is_collection?).to be false
+      end
+    end
+  end
+end

data/spec/oanda_api/client/token_client_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "OandaAPI::Client::TokenClient" do
+  let(:client) { OandaAPI::Client::TokenClient.new(:practice, "token") }
+
+  describe "#initialize" do
+    it "creates a TokenClient instance" do
+      expect(client).to be_a(OandaAPI::Client::TokenClient)
+    end
+
+    it "sets the authorization token" do
+      expect(client.auth_token).to eq("token")
+    end
+
+    it "sets the domain" do
+      expect(client.domain).to eq(:practice)
+    end
+
+    it "sets authorization headers" do
+      expect(client.headers).to eq(client.auth)
+    end
+
+    it "sets default_params to {}" do
+      expect(client.default_params).to eq({})
+    end
+  end
+
+  describe "#auth" do
+    it "returns a hash with an Authorization key" do
+      expect(client.auth["Authorization"]).to eq("Bearer token")
+    end
+  end
+
+  describe "#domain=" do
+    OandaAPI::DOMAINS.each do |domain|
+      it "allows domain :#{domain} " do
+        client.domain = domain
+        expect(client.domain).to be(domain)
+      end
+    end
+
+    it "doesn't allow invalid domains" do
+      expect { client.domain = :bogus }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "default_params" do
+    it "has a reader and writer" do
+      client.default_params = { key: "value" }
+      expect(client.default_params).to eq(key: "value")
+    end
+  end
+
+  describe "headers" do
+    it "has a reader and writer" do
+      client.headers = { key: "value" }
+      expect(client.headers).to eq(key: "value")
+    end
+  end
+end

data/spec/oanda_api/client/username_client_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "OandaAPI::Client::UsernameClient" do
+  let(:client) { OandaAPI::Client::UsernameClient.new("spongebob") }
+
+  describe "#initialize" do
+    it "sets the username" do
+      expect(client.username).to eq("spongebob")
+    end
+
+    it "sets domain to sandbox" do
+      expect(client.domain).to eq(:sandbox)
+    end
+
+    it "sets default_params to include username" do
+      expect(client.default_params).to include("username" => "spongebob")
+    end
+  end
+
+  describe "#auth" do
+    it "returns a hash with username" do
+      expect(client.auth["username"]).to eq("spongebob")
+    end
+  end
+
+  describe "#default_params" do
+    it "initialize as #auth" do
+      expect(client.default_params).to eq(client.auth)
+    end
+  end
+end

data/spec/oanda_api/configuration_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe "OandaAPI::Configuration" do
+  let(:config) { OandaAPI::Configuration.new }
+
+  describe "#datetime_format" do
+    it "returns the default datetime format" do
+      expect(config.datetime_format).to eq OandaAPI::Configuration::DATETIME_FORMAT
+    end
+  end
+
+  describe "#datetime_format=" do
+    it "overrides the default datetime format" do
+      config.datetime_format = :unix
+      expect(config.datetime_format).to eq :unix
+
+      config.datetime_format = :rfc3339
+      expect(config.datetime_format).to eq :rfc3339
+    end
+
+    it "must be a valid datetime format" do
+      expect { config.datetime_format = "X" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#rest_api_version" do
+    it "returns the default rest api version" do
+      expect(config.rest_api_version).to eq OandaAPI::Configuration::REST_API_VERSION
+    end
+  end
+
+  describe "#rest_api_version=" do
+    it "overrides the default rest api version" do
+      config.rest_api_version = "X"
+      expect(config.rest_api_version).to eq "X"
+    end
+  end
+
+  describe "#max_requests_per_second" do
+    it "returns the default max requests per second" do
+      expect(config.max_requests_per_second).to eq OandaAPI::Configuration::MAX_REQUESTS_PER_SECOND
+    end
+  end
+
+  describe "#max_requests_per_second=" do
+    it "overrides the default max requests per second" do
+      config.max_requests_per_second = 50
+      expect(config.max_requests_per_second).to eq 50
+    end
+
+    it "must be numeric" do
+      expect { config.max_requests_per_second = "X" }.to raise_error(ArgumentError)
+    end
+
+    it "must be > 0" do
+      [-10, 0].each do |val|
+        expect { config.max_requests_per_second = val }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#min_request_interval" do
+    it "is the inverse of #max_requests_per_second" do
+      config.max_requests_per_second = 2
+      expect(config.min_request_interval).to eq(0.5)
+    end
+  end
+
+  describe "#open_timeout" do
+    it "returns the default open timeout" do
+      expect(config.open_timeout).to eq OandaAPI::Configuration::OPEN_TIMEOUT
+    end
+  end
+
+  describe "#open_timeout=" do
+    it "overrides the default open timeout" do
+      config.open_timeout = 20
+      expect(config.open_timeout).to eq 20
+    end
+
+    it "must be numeric" do
+      expect { config.open_timeout = "X" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#read_timeout" do
+    it "returns the default read timeout" do
+      expect(config.read_timeout).to eq OandaAPI::Configuration::READ_TIMEOUT
+    end
+  end
+
+  describe "#read_timeout=" do
+    it "overrides the default read timeout" do
+      config.read_timeout = 20
+      expect(config.read_timeout).to eq 20
+    end
+
+    it "must be numeric" do
+      expect { config.read_timeout = "X" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#use_compression=" do
+    it "enables compression" do
+      config.use_compression = true
+      expect(config.use_compression?).to be true
+      expect(config.headers).to include("Accept-Encoding" => "deflate, gzip")
+    end
+
+    it "disables compression" do
+      config.use_compression = false
+      expect(config.use_compression?).to be false
+      expect(config.headers).to_not include("Accept-Encoding" => "deflate, gzip")
+    end
+  end
+
+  describe "#use_request_throttling=" do
+    it "enables throttling" do
+      config.use_request_throttling = true
+      expect(config.use_request_throttling?).to be true
+    end
+
+    it "disables throttling" do
+      config.use_request_throttling = false
+      expect(config.use_request_throttling?).to be false
+    end
+  end
+
+  describe "#headers" do
+    it "is a hash" do
+      expect(config.headers).to be_a Hash
+    end
+
+    it "includes a date format header" do
+      expect(config.headers).to include("X-Accept-Datetime-Format")
+    end
+  end
+end

data/spec/oanda_api/examples/accounts_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Resource::Account" do
+  let(:client) { ClientHelper.client }
+
+  it "creates a new account" do
+    VCR.use_cassette("accounts.create") do
+      account = client.accounts.create
+      expect(account).to be_an OandaAPI::Resource::Account
+    end
+  end
+
+  it "gets all accounts", :vcr do
+    VCR.use_cassette("accounts.get") do
+      accounts = client.accounts.get
+      expect(accounts.first).to be_an OandaAPI::Resource::Account
+    end
+  end
+
+  it "gets a specific account", :vcr do
+    VCR.use_cassette("accounts(id).get") do
+      account_id = client.accounts.get.first.account_id
+      account = client.accounts(account_id).get
+      expect(account).to be_an OandaAPI::Resource::Account
+    end
+  end
+end

data/spec/oanda_api/examples/orders_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'support/client_helper'
+
+describe "OandaAPI::Resource::Order" do
+  let(:account) { ClientHelper.account }
+  let(:price)   { ClientHelper.instrument("EUR_USD").bid - 0.1 }
+
+  it "creates an order", :vcr do
+    VCR.use_cassette("account(id).order(options).create") do
+      order = account.order(instrument: "EUR_USD",
+                                  type: "market",
+                                  side: "buy",
+                                 units: 10_000)
+                     .create
+      expect(order).to be_an OandaAPI::Resource::Order
+    end
+  end
+
+  it "gets all open orders", :vcr do
+    VCR.use_cassette("account(id).orders.get") do
+      ClientHelper.create_order(type: "limit", price: price)
+      orders = account.orders.get
+      expect(orders.first).to be_an OandaAPI::Resource::Order
+    end
+  end
+
+  it "gets a filtered list of open orders", :vcr do
+    VCR.use_cassette("account(id).orders(options).get") do
+      ClientHelper.create_order(instrument: "USD_JPY", type: "limit", price: price)
+
+      orders = account.orders(instrument: "USD_JPY").get
+      expect(orders.first).to be_an OandaAPI::Resource::Order
+    end
+  end
+
+  it "gets a specific open order", :vcr do
+    VCR.use_cassette("account(id).order(id).get") do
+      order_id = ClientHelper.create_order(type: "limit", price: price)
+                             .order_opened
+                             .id
+      expect(account.order(order_id).get).to be_an OandaAPI::Resource::Order
+    end
+  end
+
+  it "modifies an open order", :vcr do
+    VCR.use_cassette("account(id).order(options).update") do
+      order_id = ClientHelper.create_order(type: "limit", price: price)
+                             .order_opened
+                             .id
+      updated_order = account.order(id: order_id, units: 9_000).update
+      expect(updated_order.units).to eq 9_000
+    end
+  end
+
+  it "closes an open order", :vcr do
+    VCR.use_cassette("account(id).order(id).close") do
+      order_id = ClientHelper.create_order(type: "limit", price: price)
+                             .order_opened
+                             .id
+      before_order_ids = account.orders.get.map(&:id)
+      account.order(order_id).close
+      after_order_ids = account.orders.get.map(&:id)
+
+      expect(before_order_ids).to include order_id
+      expect(after_order_ids).not_to include order_id
+    end
+  end
+end