excoin 0.0.1

data/spec/lib/account/orders_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Excoin::Account::Orders do
+  subject {Excoin.account.orders}
+
+  it "is an Excoin::Account::Orders object" do
+    expect(subject).to be_an(Excoin::Account::Orders)
+  end
+
+  it ".all returns array of complete Order objects" do
+    expect(subject.all).to be_an(Array)
+    subject.all.each do |order|
+      expect(order).to be_an(Excoin::Account::Order)
+      expect(order.currency).to be_a(String)
+      expect(order.commodity).to be_a(String)
+      expect(order.type).to be_a(String)
+      expect(order.id).to be_a(String)
+      expect(order.timestamp).to be_a(Time)
+      expect(order.price).to be_a(BigDecimal)
+      expect(order.currency_amount).to be_a(BigDecimal)
+      expect(order.commodity_amount).to be_a(BigDecimal)
+      expect(order.status).to be_a(String)
+    end
+  end
+
+  it ".add(order) adds Order object to Orders" do
+    initial_count = subject.count
+    order = Excoin::Account::Order.new($order_data)
+    subject.add(order)
+    expect(subject.count).to eq(initial_count + 1)
+    expect(subject.all).to include{|new_order| new_order.id == $order_data['id']}
+  end
+
+  it ".delete(order_data) removes Order matching order_data from Orders" do
+    subject.delete($order_data)
+    expect(subject.all).to_not include{|order| order.id == $order_data['id']}
+  end
+
+  it ".filter(attr, value, operator) returns an array matching criteria" do
+    subject.filter("type", $type).each do |order|
+      expect(order.type).to eq($type)
+    end
+    subject.filter("currency", $currency).each do |order|
+      expect(order.currency).to eq($currency)
+    end
+    subject.filter("price", $price, :<).each do |order|
+      expect(order.price).to be < BigDecimal.new($price)
+    end
+  end
+
+end

data/spec/lib/account/trades_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Excoin::Account::Orders do
+  subject {Excoin.account.trades}
+
+  it "is an Excoin::Account::Trades object" do
+    expect(subject).to be_an(Excoin::Account::Trades)
+  end
+
+  it "has complete Excoin::Account::Trade objects" do
+    expect(subject.first).to be_an(Excoin::Account::Trade)
+    expect(subject.first.timestamp).to be_a(Time)
+    expect(subject.first.currency).to be_a(String)
+    expect(subject.first.commodity).to be_a(String)
+    expect(subject.first.type).to be_a(String)
+    expect(subject.first.price).to be_a(BigDecimal)
+    expect(subject.first.sent).to be_a(BigDecimal)
+    expect(subject.first.received).to be_a(BigDecimal)
+    expect(subject.first.fee).to be_a(BigDecimal)
+    expect(subject.first.net_received).to be_a(BigDecimal)
+  end
+
+  it "buys returns all buy trades" do
+    expect(subject.buys).to be_an(Array)
+    subject.buys.each do |trade|
+      expect(trade.type).to eq("BUY")
+    end
+  end
+
+  it "sells returns all sell trades" do
+    expect(subject.sells).to be_an(Array)
+    subject.sells.each do |trade|
+      expect(trade.type).to eq("SELL")
+    end
+  end
+
+  it "highest returns highest priced trade" do
+    expect(subject.highest).to be_an(Excoin::Account::Trade)
+    expect(subject.highest("sell")).to be_an(Excoin::Account::Trade)
+  end
+
+  it "trim(n) removes n trades" do
+    initial_size = subject.size
+    subject.trim(1)
+    expect(subject.size).to eq(initial_size - 1)
+  end
+
+  it "add(trade_data) adds a new Trade object" do
+    subject.add($trade_data)
+    expect(subject.select{|trade| trade.timestamp == Time.parse($trade_data['timestamp'])}.first).to be_an(Excoin::Account::Trade)
+  end
+end

data/spec/lib/account/wallet_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Excoin::Account do
+  subject {Excoin.account.wallet($currency)}
+
+  it "has complete Deposit objects" do
+    unless subject.deposits.empty?
+      subject.deposits.each_value do |deposit|
+        expect(deposit).to be_an(Excoin::Account::Wallet::Deposit)
+        expect(deposit.id).to be_a(String)
+        expect(deposit.timestamp).to be_a(Time)
+        expect(deposit.currency).to be_a(String)
+        expect(deposit.address).to be_a(String)
+        expect(deposit.amount).to be_a(BigDecimal)
+        expect(deposit.confirmed).to be_a(TrueClass).or be_a(FalseClass)
+      end
+    end
+
+  end
+
+  it "has complete Withdrawal objects" do
+    unless subject.withdrawals.empty?
+      subject.withdrawals.each_value do |withdrawal|
+        expect(withdrawal).to be_an(Excoin::Account::Wallet::Withdrawal)
+        expect(withdrawal.id).to be_a(String)
+        expect(withdrawal.timestamp).to be_a(Time)
+        expect(withdrawal.currency).to be_a(String)
+        expect(withdrawal.address).to be_a(String)
+        expect(withdrawal.amount).to be_a(BigDecimal)
+        expect(withdrawal.confirmed).to be_a(TrueClass).or be_a(FalseClass)
+      end
+    end
+  end
+
+  it ".deposits returns hash of all deposits" do
+    expect(subject.deposits).to be_a(Hash)
+    unless subject.deposits.empty?
+      subject.deposits.each_pair do |id, deposit_object|
+        expect(deposit_object).to be_a(Excoin::Account::Wallet::Deposit)
+      end
+    end
+  end
+
+  it ".withdrawals returns hash of all withdrawals" do
+    expect(subject.withdrawals).to be_a(Hash)
+    unless subject.withdrawals.empty?
+      subject.withdrawals.each_pair do |id, withdrawal_object|
+        expect(withdrawal_object).to be_a(Excoin::Account::Wallet::Withdrawal)
+      end
+    end
+  end
+
+  it ".unconfirmed_deposits returns hash" do
+    expect(subject.unconfirmed_deposits).to be_a(Hash)
+    subject.unconfirmed_deposits.each_pair do |id, deposit_object|
+      expect(deposit_object.confirmed).to be false
+    end
+  end
+
+  it ".unconfirmed_withdrawals returns hash" do
+    expect(subject.unconfirmed_withdrawals).to be_a(Hash)
+    subject.unconfirmed_withdrawals.each_pair do |id, withdrawal_object|
+      expect(withdrawal_object.confirmed).to be false
+    end
+  end
+
+end

data/spec/lib/exchange/candlestick_chart_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Excoin::Market::Exchange::CandlestickChart, vcr: { cassette_name: "exchange_candlestick_chart_data", match_requests_on: [:method, :uri_without_timestamp] } do
+  subject{Excoin::Market::Exchange::CandlestickChart.new($currency + $commodity)}
+
+  it "is a complete Excoin::Market::Exchange::CandlestickChart object" do
+    expect(subject).to be_an(Excoin::Market::Exchange::CandlestickChart)
+    expect(subject.currency).to be_a(String)
+    expect(subject.commodity).to be_a(String)
+    expect(subject.datapoints).to be_a(Array)
+  end
+
+  it "has complete Excoin::Market::Exchange::CandlestickChart::DataPoint objects" do
+    expect(subject.datapoints.first.timestamp).to be_a(Time)
+    expect(subject.datapoints.first.open).to be_a(BigDecimal)
+    expect(subject.datapoints.first.close).to be_a(BigDecimal)
+    expect(subject.datapoints.first.high).to be_a(BigDecimal)
+    expect(subject.datapoints.first.low).to be_a(BigDecimal)
+    expect(subject.datapoints.first.commodity_volume).to be_a(BigDecimal)
+    expect(subject.datapoints.first.currency_volume).to be_a(BigDecimal)
+  end
+
+end

data/spec/lib/exchange/exchange_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Excoin::Market::Exchange, vcr: { cassette_name: "multi_exchange_summ", match_requests_on: [:method, :uri_without_timestamp] } do
+  subject {Excoin.market.exchange($currency + $commodity)}
+
+  it "is a complete Excoin::Market::Exchange object" do
+    expect(subject.name).to be_a(String)
+    expect(subject.currency).to be_a(String)
+    expect(subject.commodity).to be_a(String)
+    expect(subject.last_price).to be_a(BigDecimal)
+    expect(subject.daily_high).to be_a(BigDecimal)
+    expect(subject.daily_low).to be_a(BigDecimal)
+    expect(subject.daily_volume).to be_a(BigDecimal)
+    expect(subject.top_bid).to be_a(BigDecimal)
+    expect(subject.lowest_ask).to be_a(BigDecimal)
+    expect(subject.spread).to be_a(BigDecimal)
+    expect(subject.orders).to be_an(Excoin::Market::Exchange::Orders)
+    expect(subject.trades).to be_an(Excoin::Market::Exchange::Trades)
+  end
+
+  context "with sufficient funds for order", vcr: { cassette_name: "account_issue_order_erb", match_requests_on: [:method, :uri_without_timestamp], erb: true } do
+    it "issue_order(type, amount, price) checks wallet balance and creates order" do
+      VCR.use_cassette("account_summary", match_requests_on: [:method, :uri_without_timestamp]) do
+        if Excoin.account.wallet(subject.currency).available_balance >= BigDecimal.new($amount)
+          id = subject.issue_order($type, $amount, $price)
+          expect(Excoin.account.order(id)).to be_truthy
+        end
+      end
+    end
+  end
+
+  context "insufficient funds" do
+    it "issue_order returns 'insufficient funds' error", vcr: { cassette_name: "account_issue_order_erb", match_requests_on: [:method, :uri_without_timestamp], erb: true } do
+       expect(subject.issue_order($type, 10000, 100)).to eq("Insufficient funds for this order (#{$currency})")
+    end
+  end
+
+end

data/spec/lib/exchange/market_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Excoin::Market do
+  subject {Excoin.market}
+
+  it "is a complete Excoin::Market object", vcr: { cassette_name: 'multi_exchange_summ', match_requests_on: [:method, :uri_without_timestamp] } do
+    expect(subject.first).to be_an(Excoin::Market::Exchange)
+  end
+
+  it "exchanges(currency) returns all exchanges with currency", vcr: { cassette_name: 'multi_exchange_summ_currency', match_requests_on: [:method, :uri_without_timestamp] } do
+    expect(subject.exchanges($currency)).to be_an(Array)
+    subject.exchanges($currency).each do |exchange|
+      expect(exchange.currency).to eq($currency)
+    end
+  end
+
+  it "exchange(exchange_name) returns matching Exchange object", vcr: { cassette_name: 'single_exchange_summary', match_requests_on: [:method, :uri_without_timestamp] } do
+    exchange = subject.exchange($currency + $commodity)
+    expect(exchange).to be_an(Excoin::Market::Exchange)
+    expect(exchange.currency).to eq($currency)
+    expect(exchange.commodity).to eq($commodity)
+  end
+end

data/spec/lib/exchange/order_depth_chart_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Excoin::Market::Exchange::OrderDepthChart, vcr: { cassette_name: "exchange_order_depth_chart_data", match_requests_on: [:method, :uri_without_timestamp] } do
+  subject{Excoin::Market::Exchange::OrderDepthChart.new($currency + $commodity)}
+
+  it "is a complete Excoin::Market::Exchange::OrderDepthChart object" do
+    expect(subject).to be_an(Excoin::Market::Exchange::OrderDepthChart)
+    expect(subject.currency).to be_a(String)
+    expect(subject.commodity).to be_a(String)
+    expect(subject.bid_orders).to be_an(Array)
+    expect(subject.ask_orders).to be_an(Array)
+  end
+
+  it "has complete Excoin::Market::Exchange::OrderDepthChart::DataPoint objects" do
+    expect(subject.bid_orders.first.type).to be_a(String)
+    expect(subject.bid_orders.first.currency_amount).to be_a(String)
+    expect(subject.bid_orders.first.price).to be_a(BigDecimal)
+  end
+
+end

data/spec/lib/exchange/orders_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Excoin::Market::Exchange::Orders, vcr: { cassette_name: "exchange_open_orders", match_requests_on: [:method, :uri_without_timestamp] } do
+  subject {Excoin.market.exchange($currency + $commodity).orders}
+
+  it "is a complete Excoin::Market::Exchange::Orders object" do
+    expect(subject).to be_an(Excoin::Market::Exchange::Orders)
+  end
+
+  it "has complete Excoin::Market::Exchange::Order objects" do
+    expect(subject.all.first).to be_an(Excoin::Market::Exchange::Order)
+    expect(subject.all.first.currency).to be_a(String)
+    expect(subject.all.first.commodity).to be_a(String)
+    expect(subject.all.first.type).to be_a(String)
+    expect(subject.all.first.price).to be_a(BigDecimal)
+    expect(subject.all.first.commodity_amount).to be_a(BigDecimal)
+    expect(subject.all.first.currency_amount).to be_a(BigDecimal)
+  end
+
+  it "adds order to Orders" do
+    order = Excoin::Market::Exchange::Order.new($order_data)
+    expect(subject.all).to_not include(order)
+    subject.add(order)
+    expect(subject.all).to include(order)
+  end
+
+  it "remove removes matching order from Orders" do
+    order = Excoin::Market::Exchange::Order.new($order_data)
+    subject.add(order)
+    initial_size = subject.all.size
+    subject.remove($order_data)
+    expect(subject.all.size).to eq(initial_size - 1)
+  end
+
+  it ".filter(attr, value, operator) returns an array matching criteria" do
+    subject.filter("type", $type).each do |order|
+      expect(order.type).to eq($type)
+    end
+    subject.filter("currency", $currency).each do |order|
+      expect(order.currency).to eq($currency)
+    end
+    subject.filter("price", $price, :<).each do |order|
+      expect(order.price).to be < BigDecimal.new($price)
+    end
+  end
+
+end

data/spec/lib/exchange/trades_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Excoin::Market::Exchange::Trades, vcr: { cassette_name: "exc_recent_trades", match_requests_on: [:method, :uri_without_timestamp] } do
+  subject {Excoin.market.exchange($currency + $commodity).trades}
+
+  it "is a complete Excoin::Market::Exchange::Trades object" do
+    expect(subject).to be_an(Excoin::Market::Exchange::Trades)
+  end
+
+  it "has complete Excoin::Market::Exchange::Trade objects" do
+    expect(subject.first).to be_an(Excoin::Market::Exchange::Trade)
+    expect(subject.first.timestamp).to be_a(Time)
+    expect(subject.first.currency).to be_a(String)
+    expect(subject.first.commodity).to be_a(String)
+    expect(subject.first.type).to be_a(String)
+    expect(subject.first.price).to be_a(BigDecimal)
+    expect(subject.first.commodity_amount).to be_a(BigDecimal)
+    expect(subject.first.currency_amount).to be_a(BigDecimal)
+  end
+
+  it "buys returns all buy trades" do
+    expect(subject.buys).to be_an(Array)
+    subject.buys.each do |trade|
+      expect(trade.type).to eq("BUY")
+    end
+  end
+
+  it "sells returns all sell trades" do
+    expect(subject.sells).to be_an(Array)
+    subject.sells.each do |trade|
+      expect(trade.type).to eq("SELL")
+    end
+  end
+
+  it "highest returns highest priced trade" do
+    expect(subject.highest).to be_an(Excoin::Market::Exchange::Trade)
+    expect(subject.highest("sell")).to be_an(Excoin::Market::Exchange::Trade)
+  end
+
+  it "trim(n) removes n trades" do
+    initial_size = subject.size
+    subject.trim(1)
+    expect(subject.size).to eq(initial_size - 1)
+  end
+
+  it "add(trade_data) adds a new Trade object" do
+    subject.add($exchange_trade_data)
+    expect(subject.select{|trade| trade.timestamp == Time.parse($trade_data['timestamp'])}.first).to be_an(Excoin::Market::Exchange::Trade)
+  end
+end

data/spec/lib/excoin/api_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+describe Excoin::API do
+  subject {Excoin.api}
+
+  describe "multiple_exchange_summary" do
+    context "without parameters" do
+      it "returns array of exchange hashes", vcr: { cassette_name: 'multi_exchange_summ', match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.multiple_exchange_summary
+        expect(response_body).to be_an(Array)
+        expect(response_body.first).to be_a(Hash)
+      end
+    end
+
+    context "with currency parameter" do
+      it "returns exchange array by currency", vcr: { cassette_name: 'multi_exchange_summ_currency', match_requests_on: [:method, :uri_without_timestamp] }  do
+        response_body = subject.multiple_exchange_summary($currency)
+        expect(response_body).to be_an(Array)
+        response_body.each do |exchange|
+          expect(exchange['currency']).to eq($currency)
+        end
+      end
+    end
+  end
+
+  describe "exchange_summary" do
+    it "returns exchange summary hash", vcr: { cassette_name: "single_exchange_summary", match_requests_on: [:method, :uri_without_timestamp] } do
+      response_body = subject.exchange_summary($currency, $commodity)
+      expect(response_body["currency"]).to eq($currency)
+      expect(response_body["commodity"]).to eq($commodity)
+    end
+  end
+
+  describe "exchange_recent_trades" do
+    context "without params" do
+      it "returns recent trades array", vcr: { cassette_name: "exc_recent_trades", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_recent_trades($currency, $commodity)
+        expect(response_body.has_key?("trades")).to be true
+      end
+    end
+    context "with count limit" do
+      it "returns recent trades array", vcr: { cassette_name: "exc_recent_trades_count", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_recent_trades($currency, $commodity, "count", "5")
+        expect(response_body.has_key?("trades")).to be true
+        expect(response_body["count"]).to eq(5)
+      end
+    end
+    context "with timestamp limit" do
+      it "returns recent trades array", vcr: { cassette_name: "exc_recent_trades_timestamp", match_requests_on: [:method, :uri_without_timestamp], record: :new_episodes } do
+        time_utc= Time.now.utc - 24*60*60
+        time_limit = time_utc.to_i
+        response_body = subject.exchange_recent_trades($currency, $commodity, "timestamp", time_limit)
+        response_body["trades"].each do |trade|
+          expect(Time.parse(trade["timestamp"])).to be > time_utc
+        end
+      end
+    end
+  end
+
+  describe "exchange_open_orders" do
+    context "without type parameter" do
+      it "returns exchange open orders array", vcr: { cassette_name: "exchange_open_orders", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_open_orders($currency, $commodity)
+        expect(response_body).to be_an(Array)
+      end
+    end
+
+    context "with type parameter" do
+      it "returns exchange open orders array, grouped by type", vcr: { cassette_name: "exchange_open_orders_type", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_open_orders($currency, $commodity, $type)
+        expect(response_body["type"]).to eq($type)
+      end
+    end
+  end
+
+  describe "exchange_candlestick_chart_data" do
+    context "without parameters" do
+      it "returns array of datapoint hashes", vcr: { cassette_name: "exchange_candlestick_chart_data", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_candlestick_chart_data($currency, $commodity)
+        expect(response_body).to be_an(Array)
+        expect(response_body.first).to be_a(Hash)
+      end
+    end
+
+    context "with duration parameter" do
+      it "returns array of datapoint hashes", vcr: { cassette_name: "exchange_candlestick_chart_data_duration", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.exchange_candlestick_chart_data($currency, $commodity, "1D")
+        expect(response_body).to be_an(Array)
+        expect(Time.parse(response_body.last['timestamp']) - Time.parse(response_body.first['timestamp'])).to be <= 86400
+      end
+    end
+  end
+
+  describe "exchange_order_depth_chart_data" do
+    it "returns array of datapoint hashes", vcr: { cassette_name: "exchange_order_depth_chart_data", match_requests_on: [:method, :uri_without_timestamp] } do
+      response_body = subject.exchange_order_depth_chart_data($currency, $commodity)
+      expect(response_body).to be_an(Array)
+      expect(response_body.first).to be_a(Hash)
+    end
+  end
+
+  describe "account_summary" do
+    it "returns account summary array", vcr: { cassette_name: "account_summary", match_requests_on: [:method, :uri_without_timestamp] } do
+      response_body = subject.account_summary
+      expect(response_body['username']).to be_a(String)
+    end
+  end
+
+  describe "account_withdraw" do
+    it "returns withdrawal hash", vcr: { cassette_name: "account_withdraw", match_requests_on: [:method, :uri_without_timestamp], record: :new_episodes } do
+      response_body = subject.account_withdraw($currency, $address, $amount)
+      expect(response_body['address']).to eq($address)
+      expect(response_body['amount']).to eq($amount)
+    end
+  end
+
+  describe "account_generate_deposit_address" do
+    it "returns hash with address", vcr: { cassette_name: "account_generate_deposit_address", match_requests_on: [:method, :uri_without_timestamp] } do
+      response_body = subject.account_generate_deposit_address($commodity)
+      expect(response_body['address']).to match(/\A[\S][a-km-zA-HJ-NP-Z0-9]{26,33}\z/)
+    end
+  end
+
+  describe "account_trades" do
+    context "with default count parameter (100)" do
+      it "returns hash with counts and trades hashes", vcr: { cassette_name: "account_trades", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.account_trades
+        expect(response_body.has_key?("trades")).to be true
+        expect(response_body["trades"].size).to be <= 100
+        expect(response_body["count"].to_i).to be <= 100
+      end
+    end
+
+    context "with custom count parameter (#{$count})" do
+      it "returns hash with counts and trades hashes", vcr: { cassette_name: "account_trades_count", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.account_trades($count)
+        expect(response_body.has_key?("trades")).to be true
+        expect(response_body["trades"].size).to be <= $count
+        expect(response_body["count"].to_i).to be <= $count
+      end
+    end
+  end
+
+  describe "account_open_orders" do
+    context "without parameters" do
+      it "returns array of exchange+type hashes", vcr: { cassette_name: "account_open_orders", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.account_open_orders
+        expect(response_body).to be_an(Array)
+        expect(response_body.first).to be_a(Hash)
+      end
+    end
+
+    context "with currency and commodity parameters" do
+      it "returns hash of bids and asks for the currency and commodity specified", vcr: { cassette_name: "account_open_orders_exchange",
+                                                                                          match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.account_open_orders($currency, $commodity)
+        expect(response_body["currency"]).to eq($currency)
+        expect(response_body["commodity"]).to eq($commodity)
+        expect(response_body["orders"].count).to eq(2)
+      end
+    end
+
+    context "with currency, commodity, and type parameters" do
+      it "returns a hash for the currency, commodity, and type specified", vcr: { cassette_name: "account_open_orders_exchange_type",
+                                                                                  match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.account_open_orders($currency, $commodity, $type)
+        expect(response_body["orders"].first["type"]).to eq($type)
+        expect(response_body["currency"]).to eq($currency)
+        expect(response_body["commodity"]).to eq($commodity)
+        expect(response_body["orders"].count).to eq(1)
+      end
+    end
+  end
+
+  describe "account issue_order" do
+    it "returns an order hash", vcr: { cassette_name: "account_issue_order_erb", match_requests_on: [:method, :uri_without_timestamp], erb: true } do
+      response_body = subject.account_issue_order($currency, $commodity, $type, $amount, $price)
+      expect(response_body["type"]).to eq($type)
+      expect(BigDecimal.new(response_body["price"])).to eq(BigDecimal.new($price))
+      if $type == "BID"
+        expect(BigDecimal.new(response_body["currency_amount"])).to eq(BigDecimal.new($amount))
+      elsif $type == "ASK"
+        expect(BigDecimal.new(response_body["commodity_amount"])).to eq(BigDecimal.new($amount))
+      end
+    end
+  end
+
+  describe "account_view_order" do
+    it "returns an order hash matching #{$order_id}", vcr: { cassette_name: "account_view_order_erb", match_requests_on: [:method, :uri_without_timestamp], erb: { order_id: $order_id } } do
+      response_body = subject.account_view_order($order_id)
+      expect(response_body["id"]).to eq($order_id)
+    end
+  end
+
+  describe "account_cancel_order" do
+      it "returns an order hash matching #{$order_id}", vcr: { cassette_name: "account_cancel_order_erb", match_requests_on: [:method, :uri_without_timestamp], erb: { order_id: $order_id } } do
+        response_body = subject.account_cancel_order($order_id)
+        expect(response_body["id"]).to eq($order_id)
+        expect(response_body["status"]).to eq("CLOSED")
+      end
+    end
+
+  describe "excoin_wallets_summary" do
+    context "without coin parameter" do
+      it "returns array of wallet hashes", vcr: { cassette_name: "excoin_wallets_summary", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.excoin_wallets_summary
+        expect(response_body).to be_an(Array)
+        expect(response_body.first.has_key?("iso_code")).to be true
+      end
+    end
+
+    context "with coin parameter" do
+      it "returns wallet hash", vcr: { cassette_name: "excoin_wallets_summary_coin", match_requests_on: [:method, :uri_without_timestamp] } do
+        response_body = subject.excoin_wallets_summary($currency)
+        expect(response_body["iso_code"]).to eq($currency)
+      end
+    end
+  end
+
+  describe "excoin_wallet_reserves(currency)" do
+    it "returns a hash with reserve info ", vcr: { cassette_name: "excoin_wallet_reserves", match_requests_on: [:method, :uri_without_timestamp] } do
+      response_body = subject.excoin_wallet_reserves($currency)
+      expect(response_body["iso_code"]).to eq($currency)
+      expect(response_body["hot_addresses"]).to be_an(Array)
+    end
+  end
+
+end