bitx 0.0.1 → 0.2.2

data/lib/public_api.rb

@@ -0,0 +1,77 @@
+module PublicApi
+
+  def ticker(pair)
+    t = self.get('/api/1/ticker', {pair: pair})
+    {
+      pair: pair,
+      timestamp: Time.at(t['timestamp'].to_i/1000),
+      ask: BigDecimal(t['ask']),
+      bid: BigDecimal(t['bid']),
+      last: BigDecimal(t['last_trade']),
+      volume: t['rolling_24_hour_volume']
+    }
+  end
+
+  def tickers
+    tickers = []
+    self.get('/api/1/tickers')['tickers'].each do |t|
+      tickers << {
+        pair: t['pair'],
+        timestamp: Time.at(t['timestamp'].to_i/1000),
+        ask: BigDecimal(t['ask']),
+        bid: BigDecimal(t['bid']),
+        last: BigDecimal(t['last_trade']),
+        volume: t['rolling_24_hour_volume']
+      }
+    end
+    tickers
+  end
+
+  def orderbook(pair)
+    t = self.get('/api/1/orderbook', {pair: pair})
+
+    bids = []
+    t['bids'].each do |o|
+      bids << {
+        price: BigDecimal(o['price']),
+        volume: BigDecimal(o['volume'])
+      }
+    end
+
+    asks = []
+    t['asks'].each do |o|
+      asks << {
+        price: BigDecimal(o['price']),
+        volume: BigDecimal(o['volume'])
+      }
+    end
+
+    {bids: bids, asks: asks, timestamp: Time.at(t['timestamp'].to_i/1000)}
+  end
+
+  def trades(pair)
+    t = self.get('/api/1/trades', {pair: pair})
+    trades = []
+    t['trades'].each do |trade|
+      trades << {
+        timestamp: Time.at(trade['timestamp'].to_i/1000),
+        price: BigDecimal(trade['price']),
+        volume: BigDecimal(trade['volume'])
+      }
+    end
+    trades
+  end
+
+  def get(url, params=nil)
+    r = self.conn.get(url, params)
+    if r.status != 200
+      raise ::BitX::Error.new("BitX error: #{r.status}")
+    end
+    t = JSON.parse r.body
+    if t['error']
+      raise ::BitX::Error.new('BitX error: ' + t['error'])
+    end
+    t
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+module BitX
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 2
+    BUILD = nil
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.');
+  end
+end

data/test/balance_test.rb

@@ -0,0 +1,58 @@
+require "minitest/pride"
+require "minitest/autorun"
+require_relative "../lib/bitx.rb"
+
+  module BalanceStubs
+    def self.conn
+     stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+
+      stub.get('/api/1/balance') {[ 200, {},
+              '{
+  "balance": [
+    {
+      "account_id": "1224342323",
+      "asset": "XBT",
+      "balance": "1.012423",
+      "reserved": "0.01",
+      "unconfirmed": "0.421"
+    },
+    {
+      "account_id": "2997473",
+      "asset": "ZAR",
+      "balance": "1000.00",
+      "reserved": "0.00",
+      "unconfirmed": "0.00"
+    }
+  ]
+}']}
+
+      end
+
+      Faraday.new do |faraday|
+        faraday.adapter :test, stubs
+      end
+    end
+  end
+
+  class TestBalance < Minitest::Test
+
+    def test_balance
+      BitX.set_conn(BalanceStubs.conn)
+
+      r = BitX.balance
+      assert_equal r.first[:reserved], 0.01
+      assert_equal r.first[:available], r.first[:balance] - r.first[:reserved]
+      assert_equal r.first[:unconfirmed], 0.421
+      assert_equal r.first[:asset], 'XBT'
+      assert_equal r.last[:account_id], '2997473'
+    end
+
+    def test_connection_balance
+      r = BitX::Connection.new(BalanceStubs.conn).balance
+      assert_equal r.first[:reserved], 0.01
+      assert_equal r.first[:available], r.first[:balance] - r.first[:reserved]
+      assert_equal r.first[:unconfirmed], 0.421
+      assert_equal r.first[:asset], 'XBT'
+      assert_equal r.last[:account_id], '2997473'
+    end
+  end

data/test/order_test.rb

@@ -0,0 +1,116 @@
+require "minitest/pride"
+require "minitest/autorun"
+require_relative "../lib/bitx.rb"
+
+  module OrderStubs
+    def self.conn
+      stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+
+        stub.get('/api/1/listorders?pair=XBTZAR') {[ 200, {},
+              '{
+  "orders": [
+    {
+      "fee_counter": "0.00",
+      "order_id": "BXMC2CJ7HNB88U4",
+      "creation_timestamp": 1367849297609,
+      "counter": "0.00",
+      "limit_volume": "0.80",
+      "limit_price": "1000.00",
+      "state": "PENDING",
+      "base": "0.00",
+      "fee_base": "0.00",
+      "type": "ASK",
+      "expiration_timestamp": 1367935697609
+    }
+  ]
+}']}
+
+
+        stub.post('/api/1/postorder', {pair:'XBTZAR', type: 'BID', volume: '0.1', price: '1000.0'}) {[ 200, {},
+              '{
+  "order_id": "BXRANDOMORDERID23"
+}']}
+
+
+
+        stub.get('/api/1/orders/BXHW6PFRRXKFSB4') {[ 200, {},
+              '{
+  "order_id": "BXHW6PFRRXKFSB4",
+  "creation_timestamp": 1402866878367,
+  "expiration_timestamp": 0,
+  "type": "ASK",
+  "state": "PENDING",
+  "limit_price": "6500.00",
+  "limit_volume": "0.02",
+  "base": "0.00",
+  "counter": "0.00",
+  "fee_base":"0.00",
+  "fee_counter":"0.00"
+}']}
+
+        stub.post('/api/1/stoporder', {order_id: 'BXMC2CJ7HNB88U4'}) {[ 200, {},
+              '{
+  "success": true
+}']}
+
+
+      end
+
+      Faraday.new do |faraday|
+        faraday.adapter :test, stubs
+      end
+    end
+  end
+
+  class TestOrders < Minitest::Test
+
+    def setup_module
+      BitX.set_conn(OrderStubs.conn)
+    end
+    def setup_connection
+      BitX::Connection.new(OrderStubs.conn)
+    end
+
+    def test_connection_list
+      r = setup_connection.list_orders('XBTZAR')
+      assert_equal r.size, 1
+    end
+    def test_list
+      setup_module
+      r = BitX.list_orders('XBTZAR')
+      assert_equal r.size, 1
+    end
+
+
+    def test_connection_post_order
+      r = setup_connection.post_order('BID', 0.1, 1000, 'XBTZAR')
+      assert_equal r[:order_id], 'BXRANDOMORDERID23'
+    end
+    def test_post_order
+      setup_module
+      r = BitX.post_order('BID', 0.1, 1000, 'XBTZAR')
+      assert_equal r[:order_id], 'BXRANDOMORDERID23'
+    end
+
+    def test_connection_get_order
+      r = setup_connection.get_order('BXHW6PFRRXKFSB4')
+      assert_equal r[:order_id], 'BXHW6PFRRXKFSB4'
+    end
+    def test_get_order
+      setup_module
+      r = BitX.get_order('BXHW6PFRRXKFSB4')
+      assert_equal r[:order_id], 'BXHW6PFRRXKFSB4'
+    end
+
+    def test_connection_stop_order
+      r = setup_connection.stop_order('BXMC2CJ7HNB88U4')
+      assert_equal r[:success], true
+    end
+    def test_stop_order
+      setup_module
+      r = BitX.stop_order('BXMC2CJ7HNB88U4')
+      assert_equal r[:success], true
+    end
+
+
+  end

data/test/public_test.rb

@@ -0,0 +1,224 @@
+require_relative "../lib/bitx.rb"
+
+  module PublicStubs
+
+    def self.conn
+     stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+        # ticker
+        stub.get('/api/1/ticker?pair=XBTZAR') {[200, {}, '{
+  "ask": "1050.00",
+  "timestamp": 1366224386716,
+  "bid": "924.00",
+  "rolling_24_hour_volume": "12.52",
+  "last_trade": "950.00"
+}']}
+        stub.get('/api/1/ticker?pair=XBTXRP') {[200, {}, '{
+    "error": "Invalid currency pair.",
+    "error_code": "ErrInvalidPair"
+}']}
+        stub.get('/api/1/ticker?pair=xbtzar') {[200, {}, '{
+    "error": "Invalid currency pair.",
+    "error_code": "ErrInvalidPair"
+}']}
+        stub.get('/api/1/ticker?pair=ZARXBT') {[200, {}, '{
+    "error": "Invalid currency pair.",
+    "error_code": "ErrInvalidPair"
+}']}
+
+
+        # tickers
+        stub.get('/api/1/tickers') {[200, {}, '{
+  "tickers": [
+    {
+      "timestamp": 1405413955793,
+      "bid": "6801.00",
+      "ask": "6900.00",
+      "last_trade": "6900.00",
+      "rolling_24_hour_volume": "12.455579",
+      "pair":"XBTZAR"
+    },
+    {
+      "timestamp": 1405413955337,
+      "bid": "5000.00",
+      "ask":"6968.00",
+      "last_trade": "6830.00",
+      "rolling_24_hour_volume": "0.00",
+      "pair":"XBTNAD"
+    }
+  ]
+}']}
+
+        # orderbook
+        stub.get('/api/1/orderbook?pair=XBTZAR') {[200, {}, '{
+  "asks": [
+    {
+      "volume": "0.10",
+      "price": "1180.00"
+    },
+    {
+      "volume": "0.15",
+      "price": "2000.00"
+    }
+  ],
+  "bids": [
+    {
+      "volume": "0.10",
+      "price": "1100.00"
+    },
+    {
+      "volume": "0.10",
+      "price": "1000.00"
+    },
+    {
+      "volume": "0.10",
+      "price": "900.00"
+    }
+  ],
+  "timestamp": 1366305398592,
+  "currency": "ZAR"
+
+}']}
+
+        # trades
+        stub.get('/api/1/trades?pair=XBTZAR') {[200, {}, '{
+  "trades": [
+    {
+      "volume": "0.10",
+      "timestamp": 1366052621774,
+      "price": "1000.00"
+    },
+    {
+      "volume": "1.20",
+      "timestamp": 1366052620770,
+      "price": "1020.50"
+    }
+  ]
+}']}
+      end
+
+      Faraday.new do |faraday|
+        faraday.adapter :test, stubs
+      end
+    end
+
+
+  end
+
+
+
+require "minitest/pride"
+require "minitest/autorun"
+
+  class TestPublic < Minitest::Test
+
+    def setup_module
+      BitX.set_conn(PublicStubs.conn)
+    end
+
+    def setup_connection
+      BitX::Connection.new(PublicStubs.conn)
+    end
+
+    def test_ticker
+      setup_module
+      ticker = BitX.ticker('XBTZAR')
+      assert_equal ticker[:volume], '12.52'
+
+      err = assert_raises(BitX::Error) {
+        BitX.ticker('XBTXRP')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+
+      err = assert_raises(BitX::Error) {
+        BitX.ticker('xbtzar')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+
+      err = assert_raises(BitX::Error) {
+        BitX.ticker('ZARXBT')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+    end
+    def test_connection_ticker
+      cnx = setup_connection
+      ticker = cnx.ticker('XBTZAR')
+      assert_equal ticker[:volume], '12.52'
+
+      err = assert_raises(BitX::Error) {
+        cnx.ticker('XBTXRP')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+
+      err = assert_raises(BitX::Error) {
+        cnx.ticker('xbtzar')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+
+      err = assert_raises(BitX::Error) {
+        cnx.ticker('ZARXBT')
+      }
+      assert_equal err.message, 'BitX error: Invalid currency pair.'
+    end
+
+    def test_tickers
+      setup_module
+      tickers = BitX.tickers
+      assert_equal tickers.size, 2
+      assert_equal tickers.first[:pair], 'XBTZAR'
+      assert_equal tickers.first[:ask], 6900.00
+      assert_equal tickers.first[:volume], "12.455579"
+
+      assert_equal tickers.last[:volume], "0.00"
+      assert_equal tickers.last[:bid], 5000
+    end
+    def test_connection_tickers
+      tickers = setup_connection.tickers
+      assert_equal tickers.size, 2
+      assert_equal tickers.first[:pair], 'XBTZAR'
+      assert_equal tickers.first[:ask], 6900.00
+      assert_equal tickers.first[:volume], "12.455579"
+
+      assert_equal tickers.last[:volume], "0.00"
+      assert_equal tickers.last[:bid], 5000
+    end
+
+    def test_orderbook
+      setup_module
+      ob = BitX.orderbook('XBTZAR')
+      assert_equal ob[:bids].size, 3
+      assert_equal ob[:bids].first[:price], 1100
+
+      assert_equal ob[:asks].size, 2
+      assert_equal ob[:asks].last[:volume], 0.15
+      assert_equal ob[:timestamp], Time.at(1366305398)
+    end
+    def test_connection_orderbook
+      ob = setup_connection.orderbook('XBTZAR')
+      assert_equal ob[:bids].size, 3
+      assert_equal ob[:bids].first[:price], 1100
+
+      assert_equal ob[:asks].size, 2
+      assert_equal ob[:asks].last[:volume], 0.15
+      assert_equal ob[:timestamp], Time.at(1366305398)
+    end
+
+    def test_trades
+      setup_module
+      trades = BitX.trades('XBTZAR')
+      assert_equal trades.size, 2
+      assert_equal trades.first[:timestamp], Time.at(1366052621)
+      assert_equal trades.last[:volume], 1.2
+      assert_equal trades.last[:price], 1020.5
+      assert_operator trades.first[:timestamp], :>=, trades.last[:timestamp]
+    end
+    def test_connection_trades
+      setup_module
+      trades = setup_connection.trades('XBTZAR')
+      assert_equal trades.size, 2
+      assert_equal trades.first[:timestamp], Time.at(1366052621)
+      assert_equal trades.last[:volume], 1.2
+      assert_equal trades.last[:price], 1020.5
+      assert_operator trades.first[:timestamp], :>=, trades.last[:timestamp]
+    end
+  end
+