bitex_bot 0.3.7 → 0.4.0

data/spec/models/sell_opening_flow_spec.rb

@@ -1,114 +1,164 @@
 require 'spec_helper'
 
 describe BitexBot::SellOpeningFlow do
-  before(:each) do
-    Bitex.api_key = "valid_key"
-  end
-  let(:store){ BitexBot::Store.create }
+  before(:each) { Bitex.api_key = 'valid_key' }
+
+  let(:store) { BitexBot::Store.create }
 
   it { should validate_presence_of :status }
   it { should validate_presence_of :price }
   it { should validate_presence_of :value_to_use }
   it { should validate_presence_of :order_id }
-  it { should(validate_inclusion_of(:status)
-    .in_array(BitexBot::SellOpeningFlow.statuses)) }
+  it { should(validate_inclusion_of(:status).in_array(BitexBot::SellOpeningFlow.statuses)) }
 
-  describe "when creating a selling flow" do
-    it "sells 2 bitcoin" do
+  describe 'when creating a selling flow' do
+    it 'sells 2 bitcoin' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
         selling: double(quantity_to_sell_per_order: 2, profit: 0))
 
       flow = BitexBot::SellOpeningFlow.create_for_market(1000,
-        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
+        bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.order_id.should == 12345
       flow.value_to_use.should == 2
       flow.price.should >= flow.suggested_closing_price
-      flow.price.should == "20.15037593984962".to_d
+      flow.price.truncate(14).should == '20.15037593984962'.to_d
       flow.suggested_closing_price.should == 20
-      flow.order_id.should == 12345
     end
 
-    it "sells 4 bitcoin" do
+    let(:order_id) { 12_345 }
+    let(:usd_price) { '25.18_796_992_481_203'.to_d }
+    let(:suggested_closing_price) { 25.to_d }
+    let(:amount_to_sell) { 4.to_d }
+    let(:btc_balance) { 100_000.to_d }
+    let(:maker_fee) { 0.5.to_d }
+    let(:taker_fee) { 0.25.to_d }
+    let(:orderbook) { bitstamp_api_wrapper_order_book.asks }
+    let(:transactions) { bitstamp_api_wrapper_transactions_stub }
+
+    it 'sells 4 bitcoin' do
+      BitexBot::Settings.stub(
+        time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: amount_to_sell, profit: 0)
+      )
       stub_bitex_orders
-      BitexBot::Settings.stub(time_to_live: 3,
-        selling: double(quantity_to_sell_per_order: 4, profit: 0))
 
-      flow = BitexBot::SellOpeningFlow.create_for_market(1000,
-        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
-      flow.value_to_use.should == 4
+      flow =
+        BitexBot::SellOpeningFlow.create_for_market(
+          btc_balance,
+          orderbook,
+          transactions,
+          maker_fee,
+          taker_fee,
+          store
+        )
+
+      flow.order_id.should eq order_id
+      flow.value_to_use.should eq amount_to_sell
       flow.price.should >= flow.suggested_closing_price
-      flow.price.round(14).should == "25.18796992481203".to_d
-      flow.suggested_closing_price.should == 25
-      flow.order_id.should == 12345
+      flow.price.should eq usd_price
+      flow.suggested_closing_price.should eq suggested_closing_price
+    end
+
+    let(:other_fx_rate) { 10.to_d }
+
+    it 'sells 4 bitcoin' do
+      BitexBot::Settings.stub(
+        fx_rate: other_fx_rate,
+        time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: amount_to_sell, profit: 0)
+      )
+      stub_bitex_orders
+
+      flow =
+        BitexBot::SellOpeningFlow.create_for_market(
+          btc_balance,
+          orderbook,
+          transactions,
+          maker_fee,
+          taker_fee,
+          store
+        )
+
+      flow.order_id.should eq order_id
+      flow.value_to_use.should eq amount_to_sell
+      flow.price.should >= flow.suggested_closing_price * other_fx_rate
+      flow.price.truncate(13).should eq usd_price * other_fx_rate
+      flow.suggested_closing_price.should eq suggested_closing_price
     end
-    
-    it "raises the price to charge on bitex to take a profit" do
+
+    it 'raises the price to charge on bitex to take a profit' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
-        selling: double(quantity_to_sell_per_order: 4, profit: 50))
+        selling: double(quantity_to_sell_per_order: 4, profit: 50.to_d))
 
       flow = BitexBot::SellOpeningFlow.create_for_market(1000,
-        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
+        bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.order_id.should == 12345
       flow.value_to_use.should == 4
       flow.price.should >= flow.suggested_closing_price
-      flow.price.round(14).should == "37.78195488721804".to_d
+      flow.price.round(14).should == '37.78195488721804'.to_d
       flow.suggested_closing_price.should == 25
-      flow.order_id.should == 12345
     end
-    
-    it "fails when there is a problem placing the ask on bitex" do
-      Bitex::Ask.stub(:create!) do 
-        raise StandardError.new("Cannot Create")
-      end
 
+    it 'fails when there is a problem placing the ask on bitex' do
+      Bitex::Ask.stub(:create!) { raise StandardError.new('Cannot Create') }
       BitexBot::Settings.stub(time_to_live: 3,
         selling: double(quantity_to_sell_per_order: 4, profit: 50))
 
       expect do
         flow = BitexBot::SellOpeningFlow.create_for_market(100000,
-          bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
+          bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+          store)
+
         flow.should be_nil
         BitexBot::SellOpeningFlow.count.should == 0
       end.to raise_exception(BitexBot::CannotCreateFlow)
     end
-    
-    it "fails when there are not enough USD to re-buy in the other exchange" do
+
+    it 'fails when there are not enough USD to re-buy in the other exchange' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
         selling: double(quantity_to_sell_per_order: 4, profit: 50))
 
       expect do
         flow = BitexBot::SellOpeningFlow.create_for_market(1,
-          bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
+          bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+          store)
+
         flow.should be_nil
         BitexBot::SellOpeningFlow.count.should == 0
       end.to raise_exception(BitexBot::CannotCreateFlow)
     end
 
-    it "Prioritizes profit from store" do
-      store = BitexBot::Store.new(selling_profit: 0.5)
+    it 'Prioritizes profit from store' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
         selling: double(quantity_to_sell_per_order: 2, profit: 0))
 
+      store = BitexBot::Store.new(selling_profit: 0.5)
       flow = BitexBot::SellOpeningFlow.create_for_market(1000,
-        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
-      flow.price.round(14).should == "20.25112781954887".to_d
+        bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.price.round(14).should == '20.25112781954887'.to_d
     end
   end
-  
-  describe "when fetching open positions" do
-    let(:flow){ create(:sell_opening_flow) }
+
+  describe 'when fetching open positions' do
+    let(:flow) { create(:sell_opening_flow) }
 
     it 'only gets sells' do
-      flow.order_id.should == 12345
       stub_bitex_transactions
+
+      flow.order_id.should == 12345
       expect do
         all = BitexBot::SellOpeningFlow.sync_open_positions
+
         all.size.should == 1
         all.first.tap do |o|
           o.price.should == 300.0
@@ -117,50 +167,69 @@ describe BitexBot::SellOpeningFlow do
           o.transaction_id.should == 12345678
           o.opening_flow.should == flow
         end
-      end.to change{ BitexBot::OpenSell.count }.by(1)
+      end.to change { BitexBot::OpenSell.count }.by(1)
     end
-    
+
     it 'does not register the same buy twice' do
-      flow.order_id.should == 12345
       stub_bitex_transactions
+
+      flow.order_id.should == 12345
       BitexBot::SellOpeningFlow.sync_open_positions
       BitexBot::OpenSell.count.should == 1
+
       Timecop.travel 1.second.from_now
       stub_bitex_transactions(build(:bitex_sell, id: 23456))
+
       expect do
         news = BitexBot::SellOpeningFlow.sync_open_positions
         news.first.transaction_id.should == 23456
-      end.to change{ BitexBot::OpenSell.count }.by(1)
+      end.to change { BitexBot::OpenSell.count }.by(1)
     end
-    
-    it 'does not register litecoin buys' do
+
+    it 'does not register buys from another order book' do
+      Bitex::Trade.stub(all: [build(:bitex_sell, id: 23456, order_book: :btc_ars)])
+
       flow.order_id.should == 12345
-      Bitex::Trade.stub(all: [build(:bitex_sell, id: 23456, specie: :ltc)])
       expect do
         BitexBot::SellOpeningFlow.sync_open_positions.should be_empty
-      end.not_to change{ BitexBot::OpenSell.count }
+      end.not_to change { BitexBot::OpenSell.count }
       BitexBot::OpenSell.count.should == 0
     end
-    
+
     it 'does not register buys from unknown bids' do
       stub_bitex_transactions
+
       expect do
         BitexBot::SellOpeningFlow.sync_open_positions.should be_empty
-      end.not_to change{ BitexBot::OpenSell.count }
+      end.not_to change { BitexBot::OpenSell.count }
     end
   end
-  
+
   it 'cancels the associated bitex bid' do
     stub_bitex_orders
     BitexBot::Settings.stub(time_to_live: 3,
       selling: double(quantity_to_sell_per_order: 4, profit: 50))
 
     flow = BitexBot::SellOpeningFlow.create_for_market(1000,
-      bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25, store)
-    
+      bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+      store)
+
     flow.finalise!
     flow.should be_settling
     flow.finalise!
     flow.should be_finalised
   end
+
+  it 'order has expected order book' do
+    stub_bitex_orders
+    BitexBot::Settings.stub(time_to_live: 3,
+      selling: double(quantity_to_sell_per_order: 2, profit: 0))
+
+    flow = subject.class.create_for_market(1000,
+      bitstamp_api_wrapper_order_book.asks, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+      store)
+
+    order = subject.class.order_class.find(flow.order_id)
+    order.order_book.should eq BitexBot::Settings.maker_settings.order_book
+  end
 end

data/spec/spec_helper.rb

@@ -1,50 +1,53 @@
 require 'bundler/setup'
 Bundler.setup
 
-require "bitex_bot/settings"
+require 'bitex_bot/settings'
 BitexBot::Settings.load_test
-require 'bitex_bot'
-require 'factory_girl'
+
+require 'byebug'
 require 'database_cleaner'
+require 'factory_bot'
 require 'shoulda/matchers'
 require 'timecop'
 require 'webmock/rspec'
-FactoryGirl.find_definitions
 
-Dir[File.dirname(__FILE__) + '/support/*.rb'].each {|file| require file }
+require 'bitex_bot'
+FactoryBot.find_definitions
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |file| require file }
 
 # Automatically do rake db:test:prepare
 ActiveRecord::Migration.maintain_test_schema!
 
-# Transactional fixtures do not work with Selenium tests, because Capybara
-# uses a separate server thread, which the transactions would be hidden
-# from. We hence use DatabaseCleaner to truncate our test database.
+# Transactional fixtures do not work with Selenium tests, because Capybara uses a separate server thread, which the transactions
+# would be hidden from. We hence use DatabaseCleaner to truncate our test database.
 DatabaseCleaner.strategy = :truncation
 
 RSpec.configure do |config|
-  config.include(FactoryGirl::Syntax::Methods)
+  config.include(FactoryBot::Syntax::Methods)
   config.include(Shoulda::Matchers::ActiveModel)
   config.include(Shoulda::Matchers::ActiveRecord)
   config.mock_with :rspec do |mocks|
     mocks.yield_receiver_to_any_instance_implementation_blocks = true
-    mocks.syntax = [:expect, :should]
+    mocks.syntax = %i[expect should]
   end
   config.expect_with :rspec do |c|
-    c.syntax = [:expect, :should]
+    c.syntax = %i[expect should]
   end
-  
+
   config.before(:all) do
     BitexBot::Robot.logger = Logger.new('/dev/null')
-    BitexBot::Robot.test_mode = true
+  end
+
+  config.before(:each) do
+    BitexBot::Robot.stub(:sleep_for)
   end
 
   config.after(:each) do
-    DatabaseCleaner.clean       # Truncate the database
+    DatabaseCleaner.clean
     Timecop.return
   end
 
-  config.order = "random"
+  config.order = 'random'
 end
 
 I18n.enforce_available_locales = false
-

data/spec/support/bitex_stubs.rb

@@ -1,8 +1,8 @@
 module BitexStubs
-  mattr_accessor(:bids){ {} }
-  mattr_accessor(:asks){ {} }
-  mattr_accessor(:active_bids){ {} }
-  mattr_accessor(:active_asks){ {} }
+  mattr_accessor(:bids) { {} }
+  mattr_accessor(:asks) { {} }
+  mattr_accessor(:active_bids) { {} }
+  mattr_accessor(:active_asks) { {} }
 
   def stub_bitex_orders
     Bitex::Order.stub(:all) do
@@ -17,15 +17,15 @@ module BitexStubs
       BitexStubs.asks[id]
     end
 
-    Bitex::Bid.stub(:create!) do |specie, to_spend, price|
+    Bitex::Bid.stub(:create!) do |order_book, to_spend, price|
       bid = Bitex::Bid.new
       bid.id = 12345
       bid.created_at = Time.now
       bid.price = price
       bid.amount = to_spend
       bid.remaining_amount = to_spend
-      bid.status = :executing 
-      bid.specie = specie
+      bid.status = :executing
+      bid.order_book = order_book
       bid.stub(:cancel!) do
         bid.status = :cancelled
         BitexStubs.active_bids.delete(bid.id)
@@ -36,15 +36,15 @@ module BitexStubs
       bid
     end
 
-    Bitex::Ask.stub(:create!) do |specie, to_sell, price|
+    Bitex::Ask.stub(:create!) do |order_book, to_sell, price|
       ask = Bitex::Ask.new
       ask.id = 12345
       ask.created_at = Time.now
       ask.price = price
       ask.quantity = to_sell
       ask.remaining_quantity = to_sell
-      ask.status = :executing 
-      ask.specie = specie
+      ask.status = :executing
+      ask.order_book = order_book
       ask.stub(:cancel!) do
         ask.status = :cancelled
         BitexStubs.active_asks.delete(ask.id)
@@ -55,11 +55,10 @@ module BitexStubs
       ask
     end
   end
-  
+
   def stub_bitex_transactions(*extra_transactions)
-    Bitex::Trade.stub(all: extra_transactions + [
-      build(:bitex_buy), build(:bitex_sell)
-    ])
+    Bitex::Trade.stub(all: extra_transactions + [build(:bitex_buy), build(:bitex_sell)])
   end
 end
+
 RSpec.configuration.include BitexStubs

data/spec/support/bitstamp/bitstamp_api_wrapper_stubs.rb

@@ -0,0 +1,35 @@
+module BitstampApiWrapperStubs
+  def stub_bitstamp_api_wrapper_order_book
+    BitstampApiWrapper.stub(order_book: bitstamp_api_wrapper_order_book)
+  end
+
+  def bitstamp_api_wrapper_order_book
+    ApiWrapper::OrderBook.new(
+      Time.now.to_i,
+      [['30', '3'], ['25', '2'], ['20', '1.5'], ['15', '4'], ['10', '5']].map do |price, quantity|
+        ApiWrapper::OrderSummary.new(price.to_d, quantity.to_d)
+      end,
+      [['10', '2'], ['15', '3'], ['20', '1.5'], ['25', '3'], ['30', '3']].map do |price, quantity|
+        ApiWrapper::OrderSummary.new(price.to_d, quantity.to_d)
+      end
+    )
+  end
+
+  def stub_bitstamp_api_wrapper_balance(usd = nil, coin = nil, fee = nil)
+    BitstampApiWrapper.stub(:balance) do
+      ApiWrapper::BalanceSummary.new(
+        ApiWrapper::Balance.new((coin || 10).to_d, 0.to_d, (coin || 10).to_d),
+        ApiWrapper::Balance.new((usd || 100).to_d, 0.to_d, (usd || 100).to_d),
+        0.5.to_d
+      )
+    end
+  end
+
+  def bitstamp_api_wrapper_transactions_stub(price = 30.to_d, amount = 1.to_d)
+    transactions = 5.times.collect do |i|
+      ApiWrapper::Transaction.new(i, price, amount, (i+1).seconds.ago.to_i)
+    end
+  end
+end
+
+RSpec.configuration.include BitstampApiWrapperStubs

data/spec/support/bitstamp/bitstamp_stubs.rb

@@ -0,0 +1,91 @@
+module BitstampStubs
+  def stub_bitstamp_order_book
+    Bitstamp.stub(:order_book) do
+      {
+        'timestamp' => Time.now.to_i.to_s,
+        'bids' => [['30', '3'], ['25', '2'], ['20', '1.5'], ['15', '4'], ['10', '5']],
+        'asks' => [['10', '2'], ['15', '3'], ['20', '1.5'], ['25', '3'], ['30', '3']]
+      }
+    end
+  end
+
+  # [<Bitstamp::Transactions @date="1380648951", @tid=14, @price="1.9", @amount="1.1">]
+  def stub_bitstamp_transactions(price = 0.2, amount = 1 )
+    Bitstamp.stub(:transactions) do
+      5.times.collect do |i|
+        double(tid: i, date: (i+1).seconds.ago.to_i.to_s, price: price.to_s, amount: amount.to_s)
+      end
+    end
+  end
+
+  # TODO It's only used into robot_spec buy/sell_closing_flow
+  def stub_bitstamp_empty_user_transactions
+    Bitstamp.stub(user_transactions: double(all: []))
+  end
+
+  # TODO It's only used into robot_spec buy/sell_closing_flow
+  # Takes all active orders and mockes them as executed in a single transaction.
+  # If a ratio is provided then each order is only partially executed and added
+  # as a transaction and the order itself is kept in the order list.
+  def stub_bitstamp_orders_into_transactions(options = {})
+    ratio = options[:ratio] || 1
+    orders = Bitstamp.orders.all
+    transactions = orders.collect do |o|
+      usd = o.amount * o.price
+      usd, btc = o.type == 0 ? [-usd, o.amount] : [usd, -o.amount]
+      double(usd: (usd * ratio).to_s, btc: (btc * ratio).to_s,
+        btc_usd: o.price.to_s, order_id: o.id, fee: '0.5', type: 2,
+        datetime: DateTime.now.to_s)
+    end
+    Bitstamp.stub(user_transactions: double(all: transactions))
+
+    return unless ratio == 1
+    stub_bitstamp_sell
+    stub_bitstamp_buy
+  end
+
+  # TODO It's only used into robot_spec buy/sell_closing_flow_spec
+  def stub_bitstamp_sell(remote_id = nil, orders = [])
+    ensure_bitstamp_orders_stub
+    Bitstamp.orders.stub(all: orders)
+    Bitstamp.orders.stub(:sell) do |args|
+      remote_id = Bitstamp.orders.all.size + 1 if remote_id.nil?
+      ask = double(amount: args[:amount], price: args[:price], type: 1, id: remote_id,
+        datetime: DateTime.now.to_s)
+      ask.stub(:cancel!) do
+        orders = Bitstamp.orders.all.reject { |o| o.id.to_s == ask.id.to_s && o.type == 1 }
+        stub_bitstamp_sell(remote_id + 1, orders)
+      end
+      stub_bitstamp_sell(remote_id + 1, Bitstamp.orders.all + [ask])
+      ask
+    end
+  end
+
+  # TODO It's only used into robot_spec buy/sell_closing_flow_spec
+  def stub_bitstamp_buy(remote_id = nil, orders = [])
+    ensure_bitstamp_orders_stub
+    Bitstamp.orders.stub(all: orders)
+    Bitstamp.orders.stub(:buy) do |args|
+      remote_id = Bitstamp.orders.all.size + 1 if remote_id.nil?
+      bid = double(amount: args[:amount], price: args[:price], type: 0, id: remote_id,
+        datetime: DateTime.now.to_s)
+      bid.stub(:cancel!) do
+        orders = Bitstamp.orders.all.reject { |o| o.id.to_s == bid.id.to_s && o.type == 0 }
+        stub_bitstamp_buy(remote_id + 1, orders)
+      end
+      stub_bitstamp_buy(remote_id + 1, Bitstamp.orders.all + [bid])
+      bid
+    end
+  end
+
+  private
+
+  # TODO It's only used into robot_spec buy/sell_closing_flow_spec
+  def ensure_bitstamp_orders_stub
+    Bitstamp.orders
+  rescue Exception => e
+    Bitstamp.stub(orders: double)
+  end
+end
+
+RSpec.configuration.include BitstampStubs